还原拼图, 把妹收小弟神器, 让你逼格提高好几个档次.

  1 #include "Game.h"
  2 
  3 #include <map>
  4 
  5 static const auto PUZZLE_COUNT = 16;
  6 static const auto PUZZLE_WIDTH = WINDOW_WIDTH / PUZZLE_COUNT;
  7 static const auto PUZZLE_HEIGHT = WINDOW_HEIGHT / PUZZLE_COUNT;
  8 
  9 static const auto RAND_COUNT = 2000;
 10 
 11 inline bool operator <(const D2D1_POINT_2F &pos1, const D2D1_POINT_2F &pos2)
 12 {
 13     if (pos1.x == pos2.x)
 14     {
 15         return pos1.y < pos2.y;
 16     }
 17     return pos1.x < pos2.x;
 18 }
 19 
 20 enum EnumDirect {
 21     UP,
 22     RIGHT,
 23     DOWN,
 24     LEFT
 25 };
 26 
 27 namespace Utils {
 28     inline EnumDirect flipDirect(EnumDirect direct)
 29     {
 30         return direct == EnumDirect::UP ? EnumDirect::DOWN
 31             : direct == EnumDirect::DOWN ? EnumDirect::UP
 32             : direct == EnumDirect::LEFT ? EnumDirect::RIGHT
 33             : EnumDirect::LEFT;
 34     }
 35 }
 36 
 37 class Puzzle : public mmc::LImage {
 38 public:
 39     Puzzle(int x, int y, int width, int height, const std::wstring &filename) : LImage(filename)
 40     {
 41         _cliprc = D2D1::RectF(x * 1.0f, y * 1.0f, x + width * 1.0f, y + height * 1.0f);
 42     }
 43 
 44     ~Puzzle()
 45     {
 46 
 47     }
 48 
 49     virtual void doDraw(ID2D1RenderTarget *pRT, float opacity) override
 50     {
 51         auto pImg = getD2dBitmap();
 52         if (pImg)
 53         {
 54             pRT->DrawBitmap(pImg,
 55                 D2D1::RectF(0.0f, 0.0f, PUZZLE_WIDTH * 1.0f, PUZZLE_HEIGHT * 1.0f),
 56                 opacity, D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, _cliprc);
 57         }
 58     }
 59 
 60 private:
 61     D2D1_RECT_F _cliprc;
 62 };
 63 
 64 class Game::impl {
 65 public:
 66     impl(Game *pGame) : _pGame(pGame)
 67     {
 68         srand(time(0));
 69     }
 70 
 71     ~impl()
 72     {
 73 
 74     }
 75 
 76     void init()
 77     {
 78         for (auto x = 0; x != PUZZLE_COUNT; ++x)
 79         {
 80             for (auto y = 0; y != PUZZLE_COUNT; ++y)
 81             {
 82                 auto pos = D2D1::Point2F(x * PUZZLE_WIDTH * 1.0f, y * PUZZLE_HEIGHT * 1.0f);
 83 
 84                 auto pChild = new Puzzle((int)pos.x, (int)pos.y, PUZZLE_WIDTH, PUZZLE_HEIGHT, L"res/img.png");
 85                 pChild->setParent(_pGame);
 86                 pChild->setPosition(pos.x, pos.y);
 87 
 88                 _posMap.insert(std::make_pair(pos, pChild));
 89             }
 90         }
 91 
 92         mmc::LRootWindow::getInstance()->redrawWindow();
 93 
 94         auto hWnd = mmc::LRootWindow::getInstance()->getWindowHandle();
 95         rand(RAND_COUNT);
 96     }
 97 
 98     void rand(u_int count)
 99     {
100         for (auto i = 0; i != count; ++i)
101         {
102             auto direct = EnumDirect(::rand() % 4);
103             if (next(direct))
104             {
105                 _directs.push(direct);
106             }
107         }
108         mmc::LRootWindow::getInstance()->redrawWindow();
109     }
110 
111     void next()
112     {
113         static auto isIgnore = [](EnumDirect direct, std::stack<EnumDirect> &directs) {
114             return Utils::flipDirect(direct) == directs.top();
115         };
116 
117         if (_directs.empty())
118         {
119             //rand(RAND_COUNT);
120             return;
121         }
122 
123         auto isOk = false;
124         auto direct = EnumDirect::UP;
125 
126         while (!_directs.empty() && !isOk)
127         {
128             isOk = true;
129             direct = _directs.top();
130             _directs.pop();
131 
132             if (!_directs.empty() && isIgnore(direct, _directs))
133             {
134                 _directs.pop();
135                 isOk = false;
136             }
137 
138             if (_directs.size() > 1 && isOk)
139             {
140                 auto direct2 = _directs.top();
141                 _directs.pop();
142                 if (isIgnore(direct2, _directs))
143                 {
144                     _directs.pop();
145                     _directs.push(direct);
146                     isOk = false;
147                 }
148                 else
149                 {
150                     _directs.push(direct2);
151                 }
152             }
153         }
154 
155         if (isOk)
156         {
157             next(Utils::flipDirect(direct));
158             mmc::LRootWindow::getInstance()->redrawWindow();
159         }
160     }
161 
162     void doDraw(ID2D1RenderTarget *pRT, float opacity) 
163     {
164 
165     }
166 
167     void doInput(UINT uMsg, WPARAM wParam, LPARAM lParam)
168     {
169         switch (uMsg)
170         {
171         case WM_CREATE:
172             {
173                 init();
174             }
175         break;
176         case WM_TIMER:
177             {
178                 if (wParam == 1001)
179                 {
180                     next();
181                     mmc::LRootWindow::getInstance()->redrawWindow();
182                 }
183             }
184             break;
185         case WM_KEYUP:
186             {
187                 if (wParam == VK_RETURN)
188                 {
189                     SetTimer(mmc::LRootWindow::getInstance()->getWindowHandle(), 1001, 16, nullptr);
190                 }
191             }
192             break;
193         }
194     }
195 private:
196     bool next(EnumDirect direct)
197     {
198         auto pGap = getGap();
199         auto pMoveObj = find(direct);
200         if (pMoveObj != nullptr)
201         {
202             swap(pMoveObj);
203         }
204         return pMoveObj != nullptr;
205     }
206 
207     mmc::LNode *find(EnumDirect direct)
208     {
209         auto pGap = getGap();
210         auto pos = pGap->getPosition();
211         switch (direct)
212         {
213             case EnumDirect::UP:
214                 pos.y += PUZZLE_HEIGHT;
215                 break;
216             case EnumDirect::RIGHT:
217                 pos.x -= PUZZLE_WIDTH;
218                 break;
219             case EnumDirect::DOWN:
220                 pos.y -= PUZZLE_HEIGHT;
221                 break;
222             case EnumDirect::LEFT:
223                 pos.x += PUZZLE_WIDTH;
224                 break;
225         }
226         auto iter = _posMap.find(pos);
227         return iter != std::end(_posMap) ? iter->second : nullptr;
228     }
229 
230     mmc::LNode *getGap()
231     {
232         return _pGame->getChilds().back();
233     }
234 
235     void swap(mmc::LNode *pNode)
236     {
237         auto pGap = getGap();
238         auto pos1 = pGap->getPosition();
239         auto pos2 = pNode->getPosition();
240         pNode->setPosition(pos1.x, pos1.y);
241         pGap->setPosition(pos2.x, pos2.y);
242 
243         _posMap.at(pos1) = pNode;
244         _posMap.at(pos2) = pGap;
245     }
246 
247     std::stack<EnumDirect>                    _directs;
248     std::map<D2D1_POINT_2F, mmc::LNode*>    _posMap;
249     Game *_pGame;
250 };
251 
252 Game::Game() : _pimpl(new impl(this))
253 {
254     
255 }
256 
257 Game::~Game()
258 {
259 
260 }
261 
262 void Game::doDraw(ID2D1RenderTarget *pRT, float opacity)
263 {
264     _pimpl->doDraw(pRT, opacity);
265 }
266 
267 void Game::doInput(UINT uMsg, WPARAM wParam, LPARAM lParam)
268 {
269     _pimpl->doInput(uMsg, wParam, lParam);
270 }