Win32小游戏--蜘蛛纸牌

　　前一段时间完成了蜘蛛纸牌的仿写，现将过程和思路记录下来

　　首先，为了符合复用性，在win32的基本框架中，把可变的部分用c++封装起来成为一系列虚函数，这样如果再继续写游戏的话，只需要继承这个类就可以了

CGameApp.h

 #pragma once
 class CGameApp                    //接口类
 {
 public:
     virtual void OnCreatGame(){}
     virtual void OnGameDraw(){}
     virtual void OnGameRun(){}
     virtual void OnKeyDown(){}
     virtual void OnKeyUp(){}
     virtual void OnLButtonDown(){}
     virtual void OnLButtonUp(){}
     virtual void OnMouseMove(){}
 };

 #include<windows.h>
 #include"CGameApp.h"

 LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

 int CALLBACK WinMain(HINSTANCE hInstance,HINSTANCE hPreInstance,LPSTR pCmdLine,int nCmdShow)
 {
     //  1.  设计
     WNDCLASSEX wndclass;
     wndclass.cbClsExtra = ;
     wndclass.cbWndExtra = ;
     wndclass.cbSize = sizeof(wndclass);
     wndclass.hbrBackground = (HBRUSH)COLOR_WINDOW;
     wndclass.hCursor = ;
     wndclass.hIcon = ;
     wndclass.hIconSm = ;    //  窗口左上的小图标
     wndclass.hInstance = hInstance;
     wndclass.lpfnWndProc = WndProc;   //  窗口的消息处理函数
     wndclass.lpszClassName = "cyc";  //  注册窗口类的名字
     wndclass.lpszMenuName = ;
     wndclass.style = CS_HREDRAW|CS_VREDRAW;

     //  2.  注册
     if( ::RegisterClassEx(&wndclass) == FALSE)
     {
         ::MessageBox(,"注册失败","提示",MB_OK);
         return ;
     }
     // 3. 创建
     HWND hwnd = ::CreateWindow("cyc","游戏壳",WS_OVERLAPPEDWINDOW,,,,,,,hInstance,);
     if(hwnd == )
     {
         ::MessageBox(,"创建失败","提示",MB_OK);
         return ;
     }

     // 4. 显示窗口
     ::ShowWindow(hwnd,SW_SHOW);

     // 5. 消息循环
     MSG msg;
     while(::GetMessage(&msg,,,))
     {
         ::TranslateMessage(&msg);
         ::DispatchMessage(&msg);   // 分发， 调用消息的处理函数WndProc
     }

     return ;
 }

 CGameApp *p = ;
 LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 {
     switch (uMsg)
     {
     case WM_CREATE:
         {
             if(p == NULL)
                 p->OnCreatGame();

         }
         break;
     case WM_PAINT:
         {
             if(p == NULL)
                 p->OnGameDraw();

         }
         break;
     case WM_TIMER:
         {
             if(p == NULL)
                 p->OnGameRun();

         }
         break;
     case WM_KEYDOWN:
         {
             if(p == NULL)
                 p->OnKeyDown();

         }
         break;
     case WM_KEYUP:
         {
             if(p == NULL)
                 p->OnKeyUp();

         }
         break;
     case WM_LBUTTONDOWN:
         {
             if(p == NULL)
                 p->OnLButtonDown();

         }
         break;
     case WM_LBUTTONUP:
         {
             if(p == NULL)
                 p->OnLButtonUp();

         }
         break;
     case WM_MOUSEMOVE:
         {
             if(p == NULL)
                 p->OnMouseMove();

         }
         break;
     case WM_CLOSE:  //  关闭
         ::PostQuitMessage();    //  发送一个退出的消息
         break;
     }
     return DefWindowProc( hwnd,  uMsg,  wParam,  lParam);
 }

接下来就是 蜘蛛纸牌建设的过程了，先来分析一下纸牌的功能，因为蜘蛛纸牌里抛去大小王，所以1--K每副牌里有13张牌，由于我想搭建类似与纸牌类游戏框架的东西，所以分为可重写，和不可重写两个部分，不可重写的，所以类就设置为单张牌，一副牌，牌的排列，规则这些类，由于哪种游戏用几副牌，鼠标点击是否取牌，鼠标点击是否拿牌，这些有开发人员自行定义，UML如下，

在接下来分模块记录的时候也分为框架内，和框架外来进行记录

框架内：

在CCards和CPocker两个类中，均是简单的参数赋值，此处也是第一次使用STL中vector组件，在CCardsRank类中，每一张牌的属性都用结构体记录了下来，如图

并且在贴图的过程中，我多设置了一个判断来加载位图是否进入内存，为开发人员省去了加载位图的过程

 void CCardsRank::ShowRank(HDC hdc, HINSTANCE hIns)
 {
     //1==============================显示窗口的背景图============================
     if(m_hBmpWndBack == )
         m_hBmpWndBack = ::LoadBitmap(hIns,MAKEINTRESOURCE(IDB_WND_BACK));

     HDC hMemDC = ::CreateCompatibleDC(hdc);
     ::SelectObject(hMemDC,m_hBmpWndBack);
     ::BitBlt(hdc,,,,,hMemDC,,,SRCCOPY);
     ::DeleteDC(hMemDC);
     //1==============================显示窗口的背景图============================

     //2==============================显示牌=====================================
     //-------------有没有牌的背景图----------
     if(m_hBmpCardsBack == )
         m_hBmpCardsBack = ::LoadBitmap(hIns,MAKEINTRESOURCE(IDB_CARDS_BACK));
     //-------------有没有牌的背景图----------
     for(size_t i=;i<m_vecRank.size();i++)
     {
         list<Node*>::iterator ite = m_vecRank[i].begin();
         while(ite != m_vecRank[i].end())
         {
             //----------贴图-------------------
             HDC hMemDC = ::CreateCompatibleDC(hdc);

             if((*ite)->bflag == false)
                 ::SelectObject(hMemDC,m_hBmpCardsBack);
             else
                 ::SelectObject(hMemDC,(*ite)->pCards->m_hBmpCards);

             ::BitBlt(hdc,(*ite)->x,(*ite)->y,,,hMemDC,,,SRCCOPY);

             ::DeleteDC(hMemDC);
             //----------贴图------------------
             ++ite;
         }
     }
     //2==============================显示牌=====================================
 }

在CardsApp中，由于创建多少副牌是不确定的，那么就没法创建对象，在这里就使用了博客内记录的动态创建对象，只需要在CardsApp中贴上两个宏，开发人员就可以随意的创建多少副牌，在CardsApp中可以自动的去创建对象，而不用修改代码，并且重点标注的是，由于蜘蛛纸牌有松开鼠标归位的功能，所以在显示移动牌的时候，都是以牌的上一个位置为标准进行移动牌坐标的计算

 void CCardsApp::ShowCursorCards(HDC hdc)
 {
     int X = pointMouseMove.x - pointMouseDown.x;
     int Y = pointMouseMove.y - pointMouseDown.y;

     //  在 移动的距离的位置显示牌
     list<Node*>::iterator ite = m_lstCursorCards.begin();
     while(ite != m_lstCursorCards.end())
     {
         HDC hMemDC = ::CreateCompatibleDC(hdc);
         ::SelectObject(hMemDC,(*ite)->pCards->m_hBmpCards);
         ::BitBlt(hdc,(*ite)->x+X,(*ite)->y+Y,,,hMemDC,,,SRCCOPY);
         ::DeleteDC(hMemDC);
         ++ite;
     }
 }

在CRule中，进行三个判断，第一个接收牌后的操作，利用vector自身的计数函数，以及遍历链表，通过是否接收牌这个规则之后，与链表结合，更新位置，翻牌，第二个是获得鼠标点击牌的坐标，在获得之前也需要进行一系列的判断，是否光标点击在牌上，牌是否是正面，是不是最后一张能否拿起来，这些都为真之后，将牌放入光标移动的链表中，在这一步值得一提的是，运用了反向迭代器，正向迭代器比反向迭代器指向少一个元素，所以在删迭代器指向元素前，反向迭代器++，或者转为正向迭代器后--  ，第三个，如果接收失败的话，将光标链表中的牌放回原先列表的尾部

 bool CRule::ReceiveCards(POINT point, CCardsRank* pCardsRank, list<Node*>& lstCursor)
 {
     //  遍历 所有的链表
     for(size_t i=;i<pCardsRank->m_vecRank.size();i++)
     {
         //  判断坐标的 交给子类
         if(this->IsReceiveCardsRule(point,i,pCardsRank,lstCursor) == true)
         {
             //  和 i这个链表结合
             pCardsRank->m_vecRank[i].splice(pCardsRank->m_vecRank[i].end(),lstCursor);
             //  更新位置（对齐）
             this->UpDatePos(pCardsRank,i);
             //  翻牌
             if(pCardsRank->m_vecRank[m_nGetCardsListID].empty() == false)
                 pCardsRank->m_vecRank[m_nGetCardsListID].back()->bflag = true;
             m_nGetCardsListID = -;
             return true;
         }
     }
     return false;
 }
 void CRule::GetCards(POINT point, CCardsRank* pCardsRank, list<Node*>& lstCursor)
 {
     //  遍历 所有的链表
     for(size_t i=;i<pCardsRank->m_vecRank.size();i++)
     {
         //  遍历 i 个链表的所有节点
         list<Node*>::reverse_iterator rev_ite = pCardsRank->m_vecRank[i].rbegin();
         while(rev_ite != pCardsRank->m_vecRank[i].rend())
         {
             //  判断光标是否点击到这个牌上
             if(point.x >= (*rev_ite)->x && point.x <= (*rev_ite)->x+
                 && point.y >= (*rev_ite)->y && point.y <= (*rev_ite)->y+)
             {
                 //  判断是不是正面
                 if((*rev_ite)->bflag == true)
                 {
                     //  判断能不能拿起来
                     list<Node*>::iterator ite = --(rev_ite.base());
                     if( this->IsGetCardsRule(pCardsRank,i,ite) == true)
                     {
                         //  记录下标
                         m_nGetCardsListID = i;
                         //  放到光标的链表上
                         lstCursor.splice(lstCursor.end(),pCardsRank->m_vecRank[i],ite,pCardsRank->m_vecRank[i].end());
                     }
                 }
                 return;
             }
             ++rev_ite;
         }
     }
 }
 void CRule::RevertCards(CCardsRank* pCardsRank, list<Node*>& lstCursor)
 {
     if(m_nGetCardsListID != -)
     {
         //  把光标的链表 放回到 m_nGetCardsListID 这个链表尾部
         pCardsRank->m_vecRank[m_nGetCardsListID].splice(pCardsRank->m_vecRank[m_nGetCardsListID].end(),lstCursor);
         m_nGetCardsListID = -;
     }
 }

框架外：

针对于蜘蛛纸牌而言，难点在于规则的制定上，在CMyCardsRank中需要注意的点就是，这个类的构造应该使用初始化列表来写，初始化列表的作用1.初始化成员属性 2.先完成指定类的构造，也就是说没有CCardsRank这个类，哪来的CMyCardsRank呢？

CMyCardsRank::CMyCardsRank(void):CCardsRank()

并且在CCardsApp中的显示应该用双缓冲来完成，因为只要连续贴的图超过一张，就有可能多张图出现在两个显卡刷新周期之内，这样的话就会出现闪屏的问题，所以利用双缓冲再为一个兼容性DC在创建一个兼容性DC，多次贴图在第一个兼容性DC中，最后一次性显示到窗口HDC中，这就是解决窗口闪烁的双缓冲技术

 void CCardsApp::OnGameDraw()                 //  WM_PAINT
 {
     HDC dc = ::GetDC(m_hMainWnd);
     HDC hdc = ::CreateCompatibleDC(dc);
     HBITMAP hbitmap = ::CreateCompatibleBitmap(dc,,);
     ::SelectObject(hdc,hbitmap);
     //-------------------------------------------------------------
     //  显示排列
     if(m_pRank != )
         m_pRank->ShowRank(hdc,m_hIns);
     this->ShowCursorCards(hdc);
     //-------------------------------------------------------------
     ::BitBlt(dc,,,,,hdc,,,SRCCOPY);
     ::DeleteObject(hbitmap);
     ::DeleteDC(hdc);
     ::ReleaseDC(m_hMainWnd,dc);
 }

大部分的重写都在CRule中，第一个拿牌的规则，利用迭代器的移动和首个牌的数字--，来判断参数的一串是否连续，一旦连续就可以拿牌

 bool CMyRule::IsGetCardsRule(CCardsRank* pCardsRank, int nlstID, list<Node*>::iterator iteCursorPos)
 {
     int num = (*iteCursorPos)->pCards->m_nCardsNum;

     while(iteCursorPos != pCardsRank->m_vecRank[nlstID].end())
     {
         if(num != (*iteCursorPos)->pCards->m_nCardsNum)
             return false;
         --num;
         iteCursorPos++;
     }
     return true;
 }

第二个，发牌的规则，首先判断在发牌的序列中，也就是最后一个链表中是否有牌了，通过了，再判断点到的是不是发牌序列中的最后一张牌，也就是说是否触发发牌的指令，最后一个判断前十个链表中是否有空的链表

 bool CMyRule::IsOpenCards(POINT point, CCardsRank* pCardsRank)
 {
     //判断最后一个链表里是否有东西
     if(pCardsRank->m_vecRank[].empty() == false)
     {
         //判断是不是点到最后一张牌
         if(point.x >= pCardsRank->m_vecRank[].back()->x && point.x <= pCardsRank->m_vecRank[].back()->x+
             && point.y >= pCardsRank->m_vecRank[].back()->y && point.y <= pCardsRank->m_vecRank[].back()->y+)
         {
             //前十个有没有空链表
             for(int i = ;i < ;i++)
             {
                 if(pCardsRank->m_vecRank[i].empty() == true)
                     return false;
             }
             return true;
         }
     }
     return false;
 }

第三个，接收牌的规则，这个就只有两点，是否鼠标坐标在上个牌的坐标范围之内，是否鼠标选中这张牌的数字比该链表的尾结点减一

 bool CMyRule::IsReceiveCardsRule(POINT point, int nlstID, CCardsRank* pCardsRank, list<Node*>& lstCursorCards)
 {
     if(pCardsRank->m_vecRank[nlstID].empty() == true)
     {
         if(point.x >= +nlstID* && point.x <= +nlstID*+ && point.y >=  && point.y <= +)
         {
             return true;
         }
     }
     else
     {
         if(point.x >= pCardsRank->m_vecRank[nlstID].back()->x && point.x <= pCardsRank->m_vecRank[nlstID].back()->x+
             && point.y >= pCardsRank->m_vecRank[nlstID].back()->y && point.y <= pCardsRank->m_vecRank[nlstID].back()->y+)
         {
             if(lstCursorCards.front()->pCards->m_nCardsNum == pCardsRank->m_vecRank[nlstID].back()->pCards->m_nCardsNum - )
             {
                 return true;
             }
         }
     }
 }

第四个，更新坐标，这里需要注意的就是不更新松手后复位的坐标

 void CMyRule::UpDatePos(CCardsRank* pCardsRank, int nlstID)
 {
     int j = ;
     list<Node*>::iterator ite = pCardsRank->m_vecRank[nlstID].begin();
     while(ite != pCardsRank->m_vecRank[nlstID].end())
     {
         (*ite)->x = +nlstID*;
         (*ite)->y = +j*;
         ++j;
         ++ite;
     }
     this->DeleteNode(pCardsRank,nlstID);
 }

第五个，当结成连续的13张牌时，进行消除，这个判断要在接收牌时，以及发牌时进行

1.链表内至少有13个结点，最后一张牌应该是A

2.反向遍历判断有没有13张连续的正面

3.不连续或者为背面时结束

4.反向迭代器删除时要转为正向

5.删除后，尾结点翻牌

 void CMyRule::DeleteNode(CCardsRank* pCardsRank, int nlstID)
 {
     if(pCardsRank->m_vecRank[nlstID].size() >=  && pCardsRank->m_vecRank[nlstID].back()->pCards->m_nCardsNum == )
     {
         int num = ;
         list<Node*>::reverse_iterator rite = pCardsRank->m_vecRank[nlstID].rbegin();
         for(int i = ;i < ;i++)
         {
             if((*rite)->bflag == false)
                 return;
             if((*rite)->pCards->m_nCardsNum != num)
                 return;
             ++rite;
             ++num;
         }
         list<Node*>::iterator ite = rite.base();
         while(ite != pCardsRank->m_vecRank[nlstID].end())
         {
             delete (*ite);
             ite = pCardsRank->m_vecRank[nlstID].erase(ite);
         }
     }
     if(pCardsRank->m_vecRank[nlstID].empty() == false)
         pCardsRank->m_vecRank[nlstID].back()->bflag = true;

 }

从宏观上看，蜘蛛纸牌就是vector-List的应用，这也是我第一次尝试去写一个框架，代码我放在文件里了，希望各位能够指正一下

2019-07-08 11:47:46 编程小菜鸟自我总结，各位大佬可以提出自己的建议和意见，谢谢！！！