开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 查看源码
mergenewView.cpp
资源名称：Visual_C++GameDevelop.rar　[点击查看]
上传用户：sycq158
上传日期：2008-10-22
资源大小：15361k
文件大小：24k
源码类别：

游戏

开发平台：

Visual C++

mergenewView.cpp：源码内容
  1. // mergenewView.cpp : implementation of the CMergenewView class
  2. //
  3. // Copyright: 胡小民，丁展 2002.5
  5. #include "stdafx.h"
  6. #include "mergenew.h"
  8. #include "fstream.h"
  10. #include "mergenewDoc.h"
  11. #include "mergenewView.h"
  12. #include "maze.h"
  13. #include "mazeMake.h"
  14. #include "HumansWay.h"
  15. #include "microbeWay.h"
  16. #include "mazeAnaly.h"
  17. #include "head.h"
  19. #ifdef _DEBUG
  20. #define new DEBUG_NEW
  21. #undef THIS_FILE
  22. static char THIS_FILE[] = __FILE__;
  23. #endif
  24. Stack _stackarray[CONST_ANT_NUM];
  25. MStack _mStackarray[CONST_ANT_NUM];
  26. bool first=true;
  29. /////////////////////////////////////////////////////////////////////////////
  30. // CMergenewView
  32. IMPLEMENT_DYNCREATE(CMergenewView, CView)
  34. BEGIN_MESSAGE_MAP(CMergenewView, CView)
  35. //{{AFX_MSG_MAP(CMergenewView)
  36. ON_WM_KEYDOWN()
  37. ON_COMMAND(ID_NEWGAME, OnNewgame)
  38. ON_COMMAND(ID_RESULT, OnResult)
  39. ON_COMMAND(ID_DOUBLERESULT, OnDoubleresult)
  40. ON_COMMAND(ID_PERFECTMAZE, OnPerfectmaze)
  41. ON_COMMAND(ID_HUMAN_SBYS, OnHumanSbys)
  42. ON_COMMAND(ID_HUMAN_GONOW, OnHumanGonow)
  43. ON_COMMAND(ID_COMP_ANT_HUMAN, OnCompAntHuman)
  44. ON_COMMAND(ID_MICROBE_SBS, OnMicrobeSbs)
  45. ON_COMMAND(ID_MICROBE_GONOW, OnMicrobeGonow)
  46. ON_COMMAND(ID_COMP_MICRO_ANT, OnCompMicroAnt)
  47. ON_COMMAND(ID_COMP_MICRO_HUMAN, OnCompMicroHuman)
  48. ON_COMMAND(ID_RCOMP_MICRO_ANT, OnRcompMicroAnt)
  49. ON_COMMAND(ID_COMP_ALL, OnCompAll)
  50. ON_COMMAND(ID_STATISTIC, OnStatistic)
  51. ON_COMMAND(ID_SINGLE, OnSingle)
  52. ON_COMMAND(ID_WITHOUTCOOP, OnWithoutcoop)
  53. ON_COMMAND(ID_WITHSINGLE, OnWithsingle)
  54. //}}AFX_MSG_MAP
  55. // Standard printing commands
  56. ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
  57. ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
  58. ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
  59. END_MESSAGE_MAP()
  61. /////////////////////////////////////////////////////////////////////////////
  62. // CMergenewView construction/destruction
  64. CMergenewView::CMergenewView()
  65. {
  66. // TODO: add construction code here
  67. width=300/::row;
  68. point.x=1;
  69. point.y=1;
  70. showtag=false;
  71. resulttag=false;
  72. turn=false;
  73. doubleresult=false;
  74. }
  76. CMergenewView::~CMergenewView()
  77. {
  78. }
  80. BOOL CMergenewView::PreCreateWindow(CREATESTRUCT& cs)
  81. {
  82. // TODO: Modify the Window class or styles here by modifying
  83. //  the CREATESTRUCT cs
  84. return CView::PreCreateWindow(cs);
  85. }
  87. /////////////////////////////////////////////////////////////////////////////
  88. // CMergenewView drawing
  90. void CMergenewView::OnDraw(CDC* pDC)
  91. {
  92. CMergenewDoc* pDoc = GetDocument();
  93. ASSERT_VALID(pDoc);
  94. if(showtag)
  95. {
  96. DrawMerge(pDC);
  97. }
  98. if(resulttag&&turn)
  99. {
  100. DrawMerge(pDC);
  101. DrawResult(pDC);
  102. }
  103. if(doubleresult)
  104. {
  105. DrawMerge(pDC);
  106. // DrawDoubleResult(pDC);
  107. }
  108. // TODO: add draw code for native data here
  109. }
  111. /////////////////////////////////////////////////////////////////////////////
  112. // CMergenewView printing
  114. BOOL CMergenewView::OnPreparePrinting(CPrintInfo* pInfo)
  115. {
  116. // default preparation
  117. return DoPreparePrinting(pInfo);
  118. }
  120. void CMergenewView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  121. {
  122. // TODO: add extra initialization before printing
  123. }
  125. void CMergenewView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
  126. {
  127. // TODO: add cleanup after printing
  128. }
  130. /////////////////////////////////////////////////////////////////////////////
  131. // CMergenewView diagnostics
  133. #ifdef _DEBUG
  134. void CMergenewView::AssertValid() const
  135. {
  136. CView::AssertValid();
  137. }
  139. void CMergenewView::Dump(CDumpContext& dc) const
  140. {
  141. CView::Dump(dc);
  142. }
  144. CMergenewDoc* CMergenewView::GetDocument() // non-debug version is inline
  145. {
  146. ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CMergenewDoc)));
  147. return (CMergenewDoc*)m_pDocument;
  148. }
  149. #endif //_DEBUG
  151. /////////////////////////////////////////////////////////////////////////////
  152. // CMergenewView message handlers
  154. void CMergenewView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  155. {
  156. // TODO: Add your message handler code here and/or call default
  157. CClientDC dc(this);
  158. switch(nChar)
  159. {
  160. case VK_DOWN:
  161. {
  162. if(point.x+1<SIZEX_MAZE-1)
  163. if(!maze[point.x+1][point.y])
  164. {
  165. DrawColorBlocks(&dc,point);
  166. point.x++;
  167. DrawColorBlocks(&dc,point,125,125,125);
  168. }
  169. break;
  170. }
  171. case VK_LEFT:
  172. {
  173. if(point.y-1>0)
  174. if(!maze[point.x][point.y-1])
  175. {
  176. DrawColorBlocks(&dc,point);
  177. point.y--;
  178. DrawColorBlocks(&dc,point,125,125,125);
  179. }
  180. break;
  181. }
  182. case VK_RIGHT:
  183. {
  184. if(point.y+1<SIZEY_MAZE-1)
  185. if(!maze[point.x][point.y+1])
  186. {
  187. DrawColorBlocks(&dc,point);
  188. point.y++;
  189. DrawColorBlocks(&dc,point,125,125,125);
  190. }
  191. break;
  192. }
  193. case VK_UP:
  194. {
  195. if(point.x-1>0)
  196. if(!maze[point.x-1][point.y])
  197. {
  198. DrawColorBlocks(&dc,point);
  199. point.x--;
  200. DrawColorBlocks(&dc,point,125,125,125);
  201. }
  202. break;
  203. }
  204. //case VK_DOWNLEFT:
  205. case VK_DELETE:
  206. {
  207. if(point.x+1<SIZEX_MAZE-1&&point.y-1>0)
  208. if(!maze[point.x+1][point.y-1])
  209. {
  210. DrawColorBlocks(&dc,point);
  211. point.x++;
  212. point.y--;
  213. DrawColorBlocks(&dc,point,125,125,125);
  214. }
  215. break;
  216. }
  217. //case VK_DOWNRIGHT:
  218. case VK_END:
  219. {
  220. if(point.x+1<SIZEX_MAZE-1&&point.y+1<SIZEY_MAZE-1)
  221. if(!maze[point.x+1][point.y+1])
  222. {
  223. DrawColorBlocks(&dc,point);
  224. point.x++;
  225. point.y++;
  226. DrawColorBlocks(&dc,point,125,125,125);
  227. }
  228. break;
  229. }
  230. //case VK_UPLEFT:
  231. case VK_INSERT:
  232. {
  233. if(point.x-1>0&&point.y-1>0)
  234. if(!maze[point.x-1][point.y-1])
  235. {
  236. DrawColorBlocks(&dc,point);
  237. point.x--;
  238. point.y--;
  239. DrawColorBlocks(&dc,point,125,125,125);
  240. }
  241. break;
  242. }
  243. //case VK_UPRIGHT:
  244. case VK_HOME:
  245. {
  246. if(point.x-1>0&&point.y+1<SIZEY_MAZE-1)
  247. if(!maze[point.x-1][point.y+1])
  248. {
  249. DrawColorBlocks(&dc,point);
  250. point.x--;
  251. point.y++;
  252. DrawColorBlocks(&dc,point,125,125,125);
  253. }
  254. break;
  255. }
  256. default:
  257. break;
  258. }
  260. if(point.x==EXIT_ROW&&point.y==EXIT_COL)
  261. {
  262. showtag=false;
  263. resulttag=false;
  264. turn=false;
  265. point.x=1;
  266. point.y=1;
  267. MessageBox("you are wonderful");
  268. }
  270. CView::OnKeyDown(nChar, nRepCnt, nFlags);
  272. }
  273. void CMergenewView::DrawColorBlocks(CDC * pDC,CPoint point)
  274. {
  275. CBrush backbrush,*oldbrush;
  276. CRect rect;
  277. rect.top=width*point.x;
  278. rect.bottom=width*(point.x+1);
  279. rect.left=width*point.y;
  280. rect.right=width*(point.y+1);
  281. backbrush.CreateSolidBrush(RGB(255,133,0));
  282. oldbrush=pDC->SelectObject(&backbrush);
  283. pDC->Rectangle(rect);
  284. pDC->SelectObject(oldbrush);
  285. }
  286. void CMergenewView::DrawColorBlocks(CDC * pDC,CPoint point,int r,int g,int b)
  287. {
  288. CBrush backbrush,*oldbrush;
  289. CRect rect;
  290. rect.top=width*point.x;
  291. rect.bottom=width*(point.x+1);
  292. rect.left=width*point.y;
  293. rect.right=width*(point.y+1);
  294. backbrush.CreateSolidBrush(RGB(r,g,b));
  295. oldbrush=pDC->SelectObject(&backbrush);
  296. pDC->Rectangle(rect);
  297. pDC->SelectObject(oldbrush);
  298. }
  299. void CMergenewView::DrawWhiteBlocks(CDC * pDC,CPoint point)
  300. {
  301. CBrush backbrush,*oldbrush;
  302. CRect rect;
  303. rect.top=width*point.x;
  304. rect.bottom=width*(point.x+1);
  305. rect.left=width*point.y;
  306. rect.right=width*(point.y+1);
  307. backbrush.CreateSolidBrush(RGB(0,255,255));
  308. oldbrush=pDC->SelectObject(&backbrush);
  309. pDC->Rectangle(rect);
  310. pDC->SelectObject(oldbrush);
  311. }
  312. void CMergenewView::DrawWhiteBlocks(CDC * pDC,CRect& rect)
  313. {
  314. CBrush backbrush,*oldbrush;
  315. backbrush.CreateSolidBrush(RGB(0,255,255));
  316. oldbrush=pDC->SelectObject(&backbrush);
  317. pDC->Rectangle(rect);
  318. pDC->SelectObject(oldbrush);
  319. }
  321. void CMergenewView::DrawPathBlocks(CDC * pDC,CPoint point)
  322. {
  323. CBrush backbrush,*oldbrush;
  324. CRect rect;
  325. rect.top=width*point.x;
  326. rect.bottom=width*(point.x+1);
  327. rect.left=width*point.y;
  328. rect.right=width*(point.y+1);
  329. backbrush.CreateSolidBrush(RGB(100,100,100));
  330. oldbrush=pDC->SelectObject(&backbrush);
  331. pDC->Rectangle(rect);
  332. pDC->SelectObject(oldbrush);
  333. }
  334. void CMergenewView::DrawPathBlocks(CDC * pDC,CRect& rect)
  335. {
  336. CBrush backbrush,*oldbrush;
  337. backbrush.CreateSolidBrush(RGB(100,100,100));
  338. oldbrush=pDC->SelectObject(&backbrush);
  339. pDC->Rectangle(rect);
  340. pDC->SelectObject(oldbrush);
  341. }
  343. void CMergenewView::DrawColorBlocks(CDC * pDC,CRect &rect)
  344. {
  345. CBrush brush,*oldbrush;
  346. brush.CreateSolidBrush(RGB(255,123,0));
  347. oldbrush=pDC->SelectObject(&brush);
  348. pDC->Rectangle(rect);
  349. pDC->SelectObject(oldbrush);
  350. }
  351. void CMergenewView::DrawColorBlocks(CDC * pDC,CRect &rect,int r,int g,int b)
  352. {
  353. CBrush brush,*oldbrush;
  354. brush.CreateSolidBrush(RGB(r,g,b));
  355. oldbrush=pDC->SelectObject(&brush);
  356. pDC->Rectangle(rect);
  357. pDC->SelectObject(oldbrush);
  358. }
  360. void CMergenewView::DrawMerge(CDC * pDC)
  361. {
  362. CBrush brush;
  363. CRect rect;
  364. int i=0,j=0;
  365. for(i=0;i<SIZEX_MAZE;i++)
  366. {
  367. rect.top=width*i;
  368. rect.bottom=width*(i+1);
  369. for(j=0;j<SIZEY_MAZE;j++)
  370. {
  371. rect.left=width*j;
  372. rect.right=width*(j+1);
  373. if(!maze[i][j])
  374. {
  375. DrawColorBlocks(pDC,rect);
  376. }
  377. else
  378. {
  379. DrawWhiteBlocks(pDC,rect);
  380. }
  381. }
  382. }
  383. }
  385. void CMergenewView::DisplayPath (CDC *pDC)
  386. {
  387. CBrush brush;
  388. CRect rect;
  389. int i=0,j=0;
  390. for(i=0;i<SIZEX_MAZE;i++)
  391. {
  392. rect.top=width*i;
  393. rect.bottom=width*(i+1);
  394. for(j=0;j<SIZEY_MAZE;j++)
  395. {
  396. rect.left=width*j;
  397. rect.right=width*(j+1);
  398. if(::pos[i][j] && !::maze[i][j])
  399. {
  400. DrawPathBlocks(pDC,rect);
  401. }
  402. }
  403. }
  404. }
  406. void CMergenewView::DrawResult(CDC * pDC)
  407. {
  408. }
  409. void CMergenewView::DrawDoubleResult(CDC * pDC)
  410. {
  411. }
  413. void CMergenewView::OnNewgame() 
  414. {
  415. int i;
  416. Restart();
  417. // TODO: Add your command handler code here
  418. CClientDC dc(this);
  420. MInitMark();
  421. for(i=0;i<MAX_ANT_NUM;i++)
  422. _mStackarray[i].MStackEmpty();
  423. InitAll();
  424. for(i=0;i<MAX_ANT_NUM;i++)
  425. _stackarray[i].StackEmpty();
  426. InitView();
  427. DrawMerge(&dc);
  429. showtag=true;
  430. turn=true;
  431. // resulttag=false;
  432. doubleresult=false;
  433. }
  435. void CMergenewView::OnResult() 
  436. {
  437. // TODO: Add your command handler code here
  438. CClientDC dc(this);
  439. CRect rect(550,30,600,80);
  440. char a[10];
  441. a[0]=NULL;
  442. CString text;
  444. int i,j;
  445. if(turn&&!found)
  446. {
  447. DrawMerge(&dc);
  449. StepByStep();
  450. for(i=1;i<SIZEX_MAZE-1;i++)
  451. {
  452. for(j=1;j<SIZEY_MAZE-1;j++)
  453. {
  454. if(pos[i][j]==0)
  455. continue;
  456. text.Format("%d",pos[i][j]);
  457. dc.TextOut(j*width,i*width,text);
  458. }
  459. //dc.TextOut(;
  460. }
  461. // resulttag=true;
  462. }
  463. else if(found==true)
  464. {
  465. text.Format("%d",::step);
  466. dc.TextOut(400,200,text);
  467. }
  469. }
  470. void CMergenewView::InitView()
  471. {
  472. InitMark();
  473. for(int i=0;i<MAX_ANT_NUM;i++)
  474. _stackarray[i].NewAntsCame ();
  476. }
  477. void CMergenewView::StepByStep()
  478. {
  480. found=false;
  481. int tag=0;
  482. element position;
  483. bool x; 
  484. element temp;
  485. int j;
  486. Allocate(_stackarray,MAX_ANT_NUM,ANT);
  487. for(int i=0;i<MAX_ANT_NUM;i++)
  488. {
  489. for(j=0;j<_stackarray[i].GetLength();j++)
  490. {
  491. temp=_stackarray[i].stack[j];
  492. ::markall[temp.row][temp.col]++;
  493. }
  494. }
  496. for(i=0;i<MAX_ANT_NUM;i++)
  497. {
  498. position=_stackarray[i].GetCurrentPosition();
  499. if(position.row==EXIT_ROW&&position.col==EXIT_COL)
  500. {
  501. tag=i;
  502. found=true;
  503. }
  504. x=found;
  505. }
  506. }
  508. void CMergenewView::OnDoubleresult() 
  509. {
  510. Restart();
  511. CClientDC dc(this);
  512. CRect rect(550,30,600,80);
  513. char a[10];
  514. a[0]=NULL;
  515. CString text;
  516. int j;
  517. found=false;
  518. int tag=0;
  519. element position;
  520. bool x; 
  521. element temp;
  523. if(turn&&!found)
  524. {
  525. // DrawMerge(&dc);
  527. while(1)
  528. {
  529. // DisplayPath(&dc);
  531. Allocate(_stackarray,MAX_ANT_NUM,ANT);
  532. for(int i=0;i<MAX_ANT_NUM;i++)
  533. {
  534. for(j=0;j<_stackarray[i].GetLength();j++)
  535. {
  536. temp=_stackarray[i].stack[j];
  537. ::markall[temp.row][temp.col]++;
  538. }
  539. }
  541. for(i=0;i<MAX_ANT_NUM;i++)
  542. {
  543. position=_stackarray[i].GetCurrentPosition();
  544. if(position.row==EXIT_ROW&&position.col==EXIT_COL)
  545. {
  546. tag=i;
  547. found=true;
  548. }
  549. x=found;
  550. }
  551. if(tag)
  552. break;
  553. if(found==true)
  554. break;
  555. }
  557. }
  558. if(found==true)
  559. {
  560. CString text;
  561. text.Format("%d",::step);
  562. dc.TextOut(400,200,text);
  563. }
  564. }
  566. void CMergenewView::OnPerfectmaze() 
  567. {
  568. Restart();
  569. CClientDC dc(this);
  570. int i;
  572. MInitMark();
  573. for(i=0;i<MAX_ANT_NUM;i++)
  574. _mStackarray[i].MStackEmpty();
  576. InitAll();
  577. for(i=0;i<SIZEX_MAZE;i++)
  578. for(int j=0;j<SIZEY_MAZE;j++)
  579. maze[i][j]=1;
  581. pMazeMaker(::maze);
  582. for(i=0;i<MAX_ANT_NUM;i++)
  583. _stackarray[i].StackEmpty();
  584. InitView();
  586. // DrawMerge(&dc);
  590. showtag=true;
  591. turn=true;
  592. doubleresult=false;
  594. }
  596. void CMergenewView::HumanStepByStep ()
  597. {
  598. found=false;
  599. int tag=0;
  600. element position;
  601. bool x; 
  602. element temp;
  603. int j;
  605. // refreshSig(::markall,1,1,fromLeft);
  607. Allocate(_stackarray,MAX_ANT_NUM,HUMAN);
  609. for(int i=0;i<MAX_ANT_NUM;i++)
  610. {
  611. for(j=0;j<_stackarray[i].GetLength();j++)
  612. {
  613. temp=_stackarray[i].stack[j];
  614. ::markall[temp.row][temp.col]++;
  615. }
  616. }
  618. for(i=0;i<MAX_ANT_NUM;i++)
  619. {
  620. position=_stackarray[i].GetCurrentPosition();
  621. if(position.row==EXIT_ROW&&position.col==EXIT_COL)
  622. {
  623. tag=i;
  624. found=true;
  625. }
  626. x=found;
  627. }
  629. }
  631. void CMergenewView::OnHumanSbys() 
  632. {
  633. // TODO: Add your command handler code here
  634. CClientDC dc(this);
  635. CRect rect(550,30,600,80);
  636. char a[10];
  637. a[0]=NULL;
  638. CString text;
  640. int i,j;
  641. if(turn&&!found)
  642. {
  643. DrawMerge(&dc);
  644. HumanStepByStep();
  645. for(i=1;i<SIZEX_MAZE-1;i++)
  646. {
  647. for(j=1;j<SIZEY_MAZE-1;j++)
  648. {
  649. if(pos[i][j]==0)
  650. continue;
  651. text.Format("%d",pos[i][j]);
  652. dc.TextOut(j*width,i*width,text);
  653. }
  654. //dc.TextOut(;
  655. }
  656. // resulttag=true;
  657. }
  658. else if(found==true)
  659. {
  660. text.Format("%d",::step);
  661. dc.TextOut(400,200,text);
  662. }
  663. }
  665. void CMergenewView::OnHumanGonow() 
  666. {
  667. Restart();
  668. CClientDC dc(this);
  669. CRect rect(550,30,600,80);
  670. char a[10];
  671. a[0]=NULL;
  672. CString text;
  673. int j;
  674. found=false;
  675. int tag=0;
  676. element position;
  677. bool x; 
  678. element temp;
  680. if(turn&&!found)
  681. {
  682. DrawMerge(&dc);
  683. while(1)
  684. {
  685. // DisplayPath(&dc);
  686. // refreshSig(::markall,1,1,fromLeft);
  687. Allocate(_stackarray,MAX_ANT_NUM,HUMAN);
  688. for(int i=0;i<MAX_ANT_NUM;i++)
  689. {
  690. for(j=0;j<_stackarray[i].GetLength();j++)
  691. {
  692. temp=_stackarray[i].stack[j];
  693. ::markall[temp.row][temp.col]++;
  694. }
  695. }
  697. for(i=0;i<MAX_ANT_NUM;i++)
  698. {
  699. position=_stackarray[i].GetCurrentPosition();
  700. if(position.row==EXIT_ROW&&position.col==EXIT_COL)
  701. {
  702. tag=i;
  703. found=true;
  704. }
  705. x=found;
  706. }
  707. if(tag)
  708. break;
  709. if(found==true)
  710. break;
  711. }
  713. }
  714. if(found==true)
  715. {
  716. CString text;
  717. text.Format("%d",::step);
  718. dc.TextOut(400,200,text);
  719. }
  720. }
  722. void CMergenewView::Restart ()
  723. {
  724. ::step=0;
  725. ::found=false;
  726. ::first =true;
  727. ::totalEdge =0;
  728. ::totalLevel =0;
  729. ::treeHeight =0;
  730. ::imbalance =0;
  731. ::levelNum =0;
  732. }
  734. void CMergenewView::OnCompAntHuman() 
  735. {
  736. // TODO: Add your command handler code here
  737. int firstStep;
  738. OnPerfectmaze();
  739. OnDoubleresult();
  740. firstStep=::step;
  742. Restart();
  743. CClientDC dc(this);
  745. InitMark();
  746. for(int i=0;i<MAX_ANT_NUM;i++)
  747. _stackarray[i].StackEmpty();
  748. InitView();
  750. DrawMerge(&dc);
  752. showtag=true;
  753. turn=true;
  754. doubleresult=false;
  757. OnHumanGonow();
  759. CString text;
  760. text.Format("%d",firstStep);
  761. dc.TextOut(400,200,text);
  763. text.Format("%d",::step);
  764. dc.TextOut(450,200,text);
  765. }
  767. void CMergenewView::OnMicrobeSbs() 
  768. {
  769. // TODO: Add your command handler code here
  770. // TODO: Add your command handler code here
  772. if(::first==true)
  773. {
  774. //initial the enviorment
  775. //]MInitAll();
  776. MInitMark();
  778. for(int i=0;i<MAX_ANT_NUM;i++)
  779. ::_mStackarray[i].NewAntsCame ();
  780. found=false;
  781. first=false;
  782. }
  784. CClientDC dc(this);
  785. CRect rect(550,30,600,80);
  786. char a[10];
  787. a[0]=NULL;
  788. CString text;
  790. int i,j;
  791. if(turn&&!found)
  792. {
  793. DrawMerge(&dc);
  795. MicrobeStepByStep();
  796. for(i=1;i<SIZEX_MAZE-1;i++)
  797. {
  798. for(j=1;j<SIZEY_MAZE-1;j++)
  799. {
  800. if(pos[i][j]==0)
  801. continue;
  802. text.Format("%d",pos[i][j]);
  803. dc.TextOut(j*width,i*width,text);
  804. }
  805. }
  806. }
  807. else if(found==true)
  808. {
  809. text.Format("%d",::step);
  810. dc.TextOut(400,200,text);
  811. }
  812. }
  814. void CMergenewView::MicrobeStepByStep ()
  815. {
  816. int i;
  817. int tag;
  818. bool x;
  819. element position;
  820. MAllocate(_mStackarray,MAX_ANT_NUM);
  822. for(i=0;i<MAX_ANT_NUM;i++)
  823. {
  824. position=_mStackarray[i].GetCurrentPosition();
  825. if(position.row==EXIT_ROW&&position.col==EXIT_COL)
  826. {
  827. tag=i;
  828. break;
  829. }
  830. x=found;
  831. }
  832. }
  835. void CMergenewView::OnMicrobeGonow() 
  836. {
  837. // TODO: Add your command handler code here
  838. int i;
  839. MInitMark();
  841. for(i=0;i<MAX_ANT_NUM;i++)
  842. ::_mStackarray[i].NewAntsCame ();
  843. found=false;
  844. first=false;
  845. Restart();
  846. CClientDC dc(this);
  847. CRect rect(550,30,600,80);
  848. char a[10];
  849. a[0]=NULL;
  850. CString text;
  852. int tag=0;
  853. element position;
  854. bool x; 
  856. DrawMerge(&dc);
  857. while(1)
  858. {
  859. // DisplayPath(&dc);
  860. MAllocate(_mStackarray,MAX_ANT_NUM);
  862. for(i=0;i<MAX_ANT_NUM;i++)
  863. {
  864. position=_mStackarray[i].GetCurrentPosition();
  865. if(position.row==EXIT_ROW&&position.col==EXIT_COL)
  866. {
  867. tag=i;
  868. break;
  869. }
  870. x=::found;
  871. }
  872. if(tag)
  873. break;
  874. if(::found==true)
  875. break;
  876. }
  879. if(found==true)
  880. {
  881. CString text;
  882. text.Format("%d",::step);
  883. dc.TextOut(400,400,text);
  884. }
  885. }
  887. void CMergenewView::reInitWithoutMaze ()
  888. {
  889. Restart();
  890. InitMark();
  891. for(int i=0;i<MAX_ANT_NUM;i++)
  892. _stackarray[i].StackEmpty();
  893. InitView();
  894. showtag=true;
  895. turn=true;
  896. doubleresult=false;
  897. }
  899. void CMergenewView::OnCompMicroAnt() 
  900. {
  901. // TODO: Add your command handler code here
  902. int firstStep;
  903. CClientDC dc(this);
  905. OnPerfectmaze();
  906. OnMicrobeGonow();
  907. firstStep=::step;
  909. reInitWithoutMaze();
  910. DrawMerge(&dc);
  912. OnDoubleresult();
  914. CString text;
  915. text.Format("%d",firstStep);
  916. dc.TextOut(400,200,text);
  918. text.Format("%d",::step);
  919. dc.TextOut(450,200,text);
  920. }
  922. void CMergenewView::OnCompMicroHuman() 
  923. {
  924. // TODO: Add your command handler code here
  925. // TODO: Add your command handler code here
  926. int firstStep;
  927. OnPerfectmaze();
  928. OnMicrobeGonow();
  929. firstStep=::step;
  930. CClientDC dc(this);
  932. reInitWithoutMaze();
  933. DrawMerge(&dc);
  935. OnHumanGonow();
  937. CString text;
  938. text.Format("%d",firstStep);
  939. dc.TextOut(400,200,text);
  941. text.Format("%d",::step);
  942. dc.TextOut(450,200,text);
  943. }
  945. void CMergenewView::OnRcompMicroAnt() 
  946. {
  947. // TODO: Add your command handler code here
  948. // TODO: Add your command handler code here
  949. int firstStep;
  950. OnNewgame();
  951. OnMicrobeGonow();
  952. firstStep=::step;
  954. CClientDC dc(this);
  956. reInitWithoutMaze();
  957. DrawMerge(&dc);
  958. OnDoubleresult();
  960. CString text;
  961. text.Format("%d",firstStep);
  962. dc.TextOut(400,200,text);
  964. text.Format("%d",::step);
  965. dc.TextOut(450,200,text);
  967. }
  970. void CMergenewView::OnCompAll() 
  971. {
  972. // TODO: Add your command handler code here
  973. int firstStep;
  974. int secondStep;
  975. OnPerfectmaze();
  976. OnMicrobeGonow();
  977. firstStep=::step;
  979. CClientDC dc(this);
  980. DrawMerge(&dc);
  981. reInitWithoutMaze();
  984. OnDoubleresult();
  985. secondStep=::step;
  987. reInitWithoutMaze();
  988. DrawMerge(&dc);
  990. OnHumanGonow();
  992. CString text;
  993. text.Format("%d",firstStep);
  994. dc.TextOut(400,200,text);
  996. text.Format("%d",secondStep);
  997. dc.TextOut(450,200,text);
  999. text.Format("%d",::step);
  1000. dc.TextOut(500,200,text);
  1002. }
  1004. void CMergenewView::OnStatistic() 
  1005. {
  1006. // TODO: Add your command handler code here
  1007. fstream microbe("d:\maze\result\microbe.txt",ios::in|ios::out|ios::trunc);
  1008. fstream ant("d:\maze\result\ant.txt",ios::in|ios::out|ios::trunc); 
  1009. fstream human("d:\maze\result\human.txt",ios::in|ios::out|ios::trunc);
  1010. fstream single("d:\maze\result\single.txt",ios::in|ios::out|ios::trunc);
  1011. fstream withoutcoop("d:\maze\result\withoutcoop.txt",ios::in|ios::out|ios::trunc);
  1012. fstream mazeShape("d:\maze\result\maze.txt",ios::in|ios::out|ios::trunc);
  1013. fstream balance("d:\maze\result\balance.txt",ios::in|ios::out|ios::trunc);
  1014. fstream level("d:\maze\result\level.txt",ios::in|ios::out|ios::trunc);
  1015. fstream edge("d:\maze\result\edge.txt",ios::in|ios::out|ios::trunc);
  1016. fstream height("d:\maze\result\height.txt",ios::in|ios::out|ios::trunc);
  1017. fstream leaveNum("d:\maze\result\leaveNum.txt",ios::in|ios::out|ios::trunc);
  1019. int generated[20]={-1};
  1020. int k;
  1022. for(::row=10;::row<=50;::row+=10)
  1023. {
  1024. ::SIZEX_MAZE =2*::row+1;
  1025. ::EXIT_ROW=::SIZEX_MAZE-2;
  1026. for(::col=10;::col<=50;::col+=10)
  1027. {
  1028. ::SIZEY_MAZE =2*::col+1;
  1029. ::EXIT_COL=::SIZEY_MAZE-2;
  1031. for(::MAX_ANT_NUM =5;::MAX_ANT_NUM <=25;::MAX_ANT_NUM +=10)
  1032. {
  1033. microbe<<"Row:  "<<::row<<"     ";
  1034. ant<<"Row:  "<<::row<<"     ";
  1035. human<<"Row:  "<<::row<<"     ";
  1036. single<<"Row:  "<<::row<<"     ";
  1037. withoutcoop<<"Row:  "<<::row<<"     ";
  1038. mazeShape<<"Row:  "<<::row<<"     ";
  1039. balance<<"Row:  "<<::row<<"     ";
  1040. level<<"Row:  "<<::row<<"     ";
  1041. edge<<"Row:  "<<::row<<"     ";
  1042. height<<"Row:  "<<::row<<"     ";
  1043. leaveNum<<"Row:  "<<::row<<"     ";
  1045. microbe<<"Col:  "<<::col<<"      ";
  1046. ant<<"Col:  "<<::col<<"      ";
  1047. human<<"Col:  "<<::col<<"      ";
  1048. single<<"Col:  "<<::col<<"      ";
  1049. withoutcoop<<"Col:  "<<::col<<"      ";
  1050. mazeShape<<"Col:  "<<::col<<"      ";
  1051. balance<<"Col:  "<<::col<<"      ";
  1052. level<<"Col:  "<<::col<<"      ";
  1053. edge<<"Col:  "<<::col<<"      ";
  1054. height<<"Col:  "<<::col<<"      ";
  1055. leaveNum<<"Col:  "<<::col<<"      ";
  1057. microbe<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1058. ant<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1059. human<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1060. single<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1061. withoutcoop<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1062. mazeShape<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1063. balance<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1064. level<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1065. edge<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1066. height<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1067. leaveNum<<"Ant num:  "<<::MAX_ANT_NUM <<endl;
  1069. for(int time=0;time<20;time++)
  1070. {
  1071. OnPerfectmaze();
  1073. OnMicrobeGonow();
  1074. for(k=0;k<20;k++)
  1075. if(::step!=generated[k])
  1076. break;
  1077. if(k==20)
  1078. continue;
  1079. generated[time]=::step;
  1080. microbe<<::step<<endl;
  1081. int temp=0;
  1082. mazeAnaly(::maze,1,1,1,0,1,temp);
  1083. balance<<::imbalance <<endl;
  1084. height<<::treeHeight <<endl;
  1085. level<<::totalLevel  <<endl;
  1086. edge<<::totalEdge <<endl;
  1087. leaveNum<<::levelNum <<endl;
  1089. mazeShape<<endl;
  1090. int i=0,j=0;
  1091. for(i=0;i<SIZEX_MAZE;i++)
  1092. {
  1093. for(j=0;j<SIZEY_MAZE;j++)
  1094. mazeShape<<::maze[i][j];
  1095. mazeShape<<endl;   
  1096. }
  1098. reInitWithoutMaze();
  1099. OnDoubleresult();
  1100. ant<<::step<<endl;
  1102. reInitWithoutMaze();
  1103. OnHumanGonow();
  1104. human<<::step <<endl;
  1106. reInitWithoutMaze();
  1107. ::step=OnSingle();
  1108. single<<::step <<endl;
  1110. reInitWithoutMaze();
  1111. ::step=OnWithoutcoop();
  1112. withoutcoop<<::step <<endl;
  1113. }
  1114. }
  1115. }
  1116. }
  1117. }
  1119. int CMergenewView::OnSingle() 
  1120. {
  1121. int tempAntNum=::MAX_ANT_NUM ;
  1122. ::MAX_ANT_NUM =1;
  1123. int temp=OnWithoutcoop();
  1124. ::MAX_ANT_NUM =tempAntNum;
  1125. return temp;
  1126. }
  1128. int CMergenewView::OnWithoutcoop() 
  1129. {
  1130. // TODO: Add your command handler code here
  1131. int i;
  1132. int tag=0;
  1133. element position;
  1134. bool x; 
  1135. int withoutCoop=0;
  1136. CClientDC dc(this);
  1137. found=false;
  1138. while(1)
  1139. {
  1140. withoutCoop++;
  1141. for(i=0;i<MAX_ANT_NUM;i++)
  1142. {
  1143. _stackarray[i].SearchPathStepByStepRandom();
  1144. position=_stackarray[i].GetCurrentPosition();
  1145. if(position.row==EXIT_ROW&&position.col==EXIT_COL)
  1146. {
  1147. tag=i;
  1148. break;
  1149. }
  1150. x=found;
  1151. }
  1152. DisplayPath(&dc);
  1153. if(tag)
  1154. break;
  1155. if(found==true)
  1156. break;
  1157. }
  1158. CString text;
  1160. text.Format("%d",withoutCoop);
  1161. dc.TextOut(400,300,text);
  1162. return withoutCoop;
  1163. }
  1165. void CMergenewView::OnWithsingle() 
  1166. {
  1167. // TODO: Add your command handler code here
  1168. int firstStep;
  1169. int secondStep;
  1170. int thirdStep;
  1171. int fourthStep;
  1172. int fifthStep;
  1174. OnPerfectmaze();
  1175. OnMicrobeGonow();
  1176. firstStep=::step;
  1178. CClientDC dc(this);
  1180. reInitWithoutMaze();
  1181. OnDoubleresult();
  1182. secondStep=::step;
  1183. reInitWithoutMaze();
  1184. OnHumanGonow();
  1185. thirdStep=::step ;
  1186. reInitWithoutMaze();
  1187. fourthStep=OnSingle();
  1188. reInitWithoutMaze();
  1189. fifthStep=OnWithoutcoop();
  1191. CString text;
  1192. text.Format("%d",firstStep);
  1193. dc.TextOut(200,200,text);
  1195. text.Format("%d",secondStep);
  1196. dc.TextOut(250,200,text);
  1198. text.Format("%d",thirdStep);
  1199. dc.TextOut(300,200,text);
  1201. text.Format("%d",fourthStep);
  1202. dc.TextOut(350,200,text);
  1204. text.Format("%d",fifthStep);
  1205. dc.TextOut(400,200,text);
  1206. }