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

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

游戏

开发平台：

Visual C++

maze.h：源码内容
  1. // Copyright: 胡小民，丁展 2002.5
  3. #ifndef _MAZE_H
  4. #define _MAZE_H
  6. #include "stdio.h"
  7. #include "stdlib.h"
  8. #include "iostream.h"
  9. #include "fstream.h"
  10. #include "mazeMake.h"
  11. #include "head.h"
  14. // tell others that this path cannot be accessed in fact it describe the new maze
  16. bool found=false;
  17. int step=0;
  19. class element;
  20. class Stack;
  21. class offsets;
  23. int Max(int x,int y ,int z,int w);
  24. void GenerateMaze();
  25. long  SearchPath(Stack& _stack);
  26. void InitMark();
  27. void ShowMaze();
  28. void SimpleMaze();
  29. void SubAllocate(int count,Stack _stackarray[],int n,element position,
  30.  int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],
  31.  int pos[CONST_MAZEX][CONST_MAZEY],int &tag);
  32. void Allocate(Stack _stackarray[],int n,int type);
  33. void HumanSubAllocate(int count,Stack _stackarray[],int n,element position,
  34.  int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],
  35.  int pos[CONST_MAZEX][CONST_MAZEY],int &tag);
  38. bool Square1(int i,int j)
  39. {
  40. if(maze[i-1][j]&&maze[i][j-1]&&maze[i-1][j-1])
  41. return true;
  42. return false;
  43. }
  44. bool Square0(int i,int j)
  45. {
  46. if(!maze[i-1][j]&&!maze[i][j-1]&&!maze[i-1][j-1])
  47. return true;
  48. return false;
  49. }
  50. //----------------------------//
  51. class element
  52. {
  53. public:
  54. int row;
  55. int col;
  56. int dir;
  57. };
  58. bool EqualElement(const element a,const element b)
  59. {
  60. if(a.col==b.col&&a.row==b.row)
  61. return true;
  62. else
  63. return false;
  64. }
  65. class offsets
  66. {
  67. public:
  68. int vert;
  69. int horiz;
  70. public:
  71. void GetValue(int vert=0,int horiz=0)
  72. {
  73. this->vert=vert;
  74. this->horiz=horiz;
  75. }
  76. };
  77. //---------------------------//
  78. offsets move[4];
  80. class Stack
  81. {
  82. private:
  83. int top;
  84. element error;
  85. int count;
  86. public:
  87. element stack[MAX_STACK_SIZE];
  88. public:
  89. bool classmark[CONST_MAZEX][CONST_MAZEY];
  90. int method; // method是对走法的处理，顺时针，逆时针等等
  91. int sleep;
  92. public:
  93. Stack():top(-1)
  94. {
  95. this->InitMark();
  96. }
  97. void NewAntsCame()
  98. {
  99. this->InitMark();
  100. this->classmark[1][1]=true;
  101. ::markall[1][1]++;
  102. AddStack(1,1,1);
  103. row=1;
  104. col=1;
  105. dir=1;
  106. next_row=0;
  107. next_col=0;
  108. dir=0;
  109. count=0;
  110. pos[1][1]++;
  111. //------------------
  112. count++;
  113. position=DeleteStack();
  114. row=position.row;
  115. col=position.col;
  116. dir=position.dir;
  117. ::wild[1][1]=false;
  118. sleep=0;
  119. }
  120. void SetDir(int dir)
  121. {
  122. this->dir=dir;
  123. }
  124. void StackEmpty()
  125. {
  126. top=-1;
  128. }
  129. element DeleteStack()
  130. {
  131. if(top==-1)
  132. return error;
  133. else
  134. return stack[top--];
  135. }
  136. bool AddStack(const element & pa)
  137. {
  138. if(top==MAX_STACK_SIZE-1)
  139. return false;
  140. else
  141. {
  142. stack[++top]=pa;
  143. return true;
  144. }
  145. }
  146. bool AddStack(int row,int col,int dir)
  147. {
  148. if(top==MAX_STACK_SIZE-1)
  149. return false;
  150. else
  151. {
  152. top++;
  153. stack[top].row=row;
  154. stack[top].col=col;
  155. stack[top].dir=dir;
  156. return true;
  157. }
  158. }
  159. bool Empty()
  160. {
  161. if(top==-1)
  162. return true;
  163. else
  164. return false;
  165. }
  166. void InitMark();
  167. //
  168. private:
  169. int row,col,next_row,next_col,dir;
  170. element position;
  171. public:
  172. int SearchPathStepByStep(int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY]);
  173. bool TestDir(int dir,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY]);
  174. bool TestDirection(int dir,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY]);
  175. bool HumanTestDirection(int dir,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY]);
  176. int HumanSearchPathStepByStep(int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY]);
  177. int SearchPathStepByStepRandom();
  178. int GetLength()
  179. {
  180. return top;
  181. }
  182. element GetCurrentPosition()
  183. {
  184. element temp;
  185. temp.row=row;
  186. temp.col=col;
  187. temp.dir=0  ; // temp.dir=dir;
  188. return temp;
  189. }
  190. element GetLastPosition()
  191. {
  192. element temp;
  193. temp.row=next_row;
  194. temp.col=next_col;
  195. temp.dir=0;
  196. return temp;
  197. }
  198. ~Stack()
  199. {}
  201. };
  202. //--------------independent-------------------//
  203. void Stack::InitMark()
  204. {
  206. int i,j;
  207. for(i=0;i<CONST_MAZEX;i++)
  208. for(j=0;j<CONST_MAZEY;j++)
  209. {
  210. if(maze[i][j]==1)
  211. classmark[i][j]=true;
  212. else
  213. classmark[i][j]=false;
  214. }
  215. }
  217. // 1      2     4     8
  218. int Max(int x,int y ,int z,int w)
  219. {
  220. int max=x;
  221. int count=0;
  222. if(max<y)
  223. max=y;
  224. if(max<z)
  225. max=z;
  226. if(max<w)
  227. max=w;
  228. if(max==x)
  229. count|=1;
  230. if(max==y)
  231. count|=2;
  232. if(max==z)
  233. count|=4;
  234. if(max==w)
  235. count|=8;
  236. return count;
  237. }
  238. // if the direction is ok then i take it else i just be idle
  239. //hxm begin
  240. bool Stack::TestDir(int dir,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY])
  241. //hxm end
  242. {
  243. this->dir=dir;
  244. if(this->dir<0||this->dir>3)
  245. return false;
  246. next_row=row+move[dir].vert;
  247. next_col=col+move[dir].horiz;
  248. if(next_row==EXIT_ROW&&next_col==EXIT_COL)
  249. {
  250. found=true;
  251. ::mark[next_row][next_col]=true;
  252. ::markall[next_row][next_col]++;
  254. ::pos[next_row][next_col]++;
  255. ::pos[row][col]--;
  256. ::wild[next_row][next_col]=false;
  258. position.row=row;
  259. position.col=col;
  260. position.dir=--dir;
  261. AddStack(position);
  262. row=next_row;
  263. col=next_col;
  264. dir=3;
  265. AddStack(row,col,dir);
  266. count++;
  267. return true;
  268. }
  269. else
  270. //   墙 在栈里 别人设的墙
  271. if(!maze[next_row][next_col]&&!classmark[next_row][next_col]&&!mark[next_row][next_col])
  272. {
  273. classmark[next_row][next_col]=true;
  274. ::pos[row][col]--;
  275. ::pos[next_row][next_col]++;
  276. ::wild[next_row][next_col]=false;
  277. position.row=row;
  278. position.col=col;
  279. position.dir=++this->dir;
  280. AddStack(position);
  281. row=next_row;
  282. col=next_col;
  283. this->dir=0;
  284. count++;
  285. return true;
  286. }
  288. return false;
  289. }
  291. bool Stack::TestDirection(int dir,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY])
  292. {
  293. this->dir=dir;
  294. if(this->dir<0||this->dir>3)
  295. return false;
  296. int num=0;
  297. while(num<4)
  298. {
  299. this->dir=this->dir%4;
  300. next_row=row+move[this->dir].vert;
  301. next_col=col+move[this->dir].horiz;
  302. if(next_row==EXIT_ROW&&next_col==EXIT_COL)
  303. {
  304. found=true;
  305. classmark[next_row][next_col]=true;
  306. ::wild[next_row][next_col]=false;
  308. ::pos[next_row][next_col]++;
  309. ::pos[row][col]--;
  311. position.row=row;
  312. position.col=col;
  313. position.dir=--dir;
  314. AddStack(position);
  315. row=next_row;
  316. col=next_col;
  317. dir=3;
  318. AddStack(row,col,dir);
  319. count++;
  320. return true;
  321. }
  322. else
  323. if(!maze[next_row][next_col]&&!classmark[next_row][next_col]&&!mark[next_row][next_col])
  324. {
  325. classmark[next_row][next_col]=true;
  326. ::pos[row][col]--;
  327. ::pos[next_row][next_col]++;
  328. ::wild[next_row][next_col]=false;
  330. position.row=row;
  331. position.col=col;
  332. position.dir=++this->dir;
  333. AddStack(position);
  334. row=next_row;
  335. col=next_col;
  336. this->dir=0;
  337. count++;
  338. return true;
  339. }
  340. else
  341. {
  342. ++this->dir;
  343. num++;
  344. if(num==4)
  345. {
  346. ::mark[row][col]=true;// tell others donot take this way;
  347. count++;
  348. ::pos[row][col]--;
  349. ::markall[row][col]=UNACCESSABLE;
  350. position=DeleteStack();
  351. row=position.row;
  352. col=position.col;
  353. this->dir=position.dir;
  354. ::pos[row][col]++;
  355. return false;
  356. }
  357. }
  358. }
  360. return false;
  361. }
  363. bool Stack::HumanTestDirection(int dir,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY])
  364. {
  365. this->dir=dir;
  366. if(this->dir<0||this->dir>3)
  367. return false;
  368. int num=0;
  369. while(num<4)
  370. {
  371. this->dir=this->dir%4;
  372. next_row=row+move[this->dir].vert;
  373. next_col=col+move[this->dir].horiz;
  374. if(next_row==EXIT_ROW&&next_col==EXIT_COL)
  375. {
  376. found=true;
  377. classmark[next_row][next_col]=true;
  378. ::wild[next_row][next_col]=false;
  380. ::pos[next_row][next_col]++;
  381. ::pos[row][col]--;
  383. position.row=row;
  384. position.col=col;
  385. position.dir=--dir;
  386. AddStack(position);
  387. row=next_row;
  388. col=next_col;
  389. dir=3;
  390. AddStack(row,col,dir);
  391. count++;
  392. return true;
  393. }
  394. else
  395. if(!maze[next_row][next_col]&&!classmark[next_row][next_col]&&!mark[next_row][next_col])
  396. {
  397. classmark[next_row][next_col]=true;
  398. ::pos[row][col]--;
  399. ::pos[next_row][next_col]++;
  400. ::wild[next_row][next_col]=false;
  402. position.row=row;
  403. position.col=col;
  404. position.dir=++this->dir;
  405. AddStack(position);
  406. row=next_row;
  407. col=next_col;
  408. this->dir=0;
  409. count++;
  410. return true;
  411. }
  412. else
  413. {
  414. ++this->dir;
  415. num++;
  416. Stack temp;
  417. temp=*this;
  418. if(num==4)
  419. {
  420. ::mark[row][col]=true;// tell others donot take this way;
  421. count++;
  422. ::pos[row][col]--;
  423. ::markall[row][col]=UNACCESSABLE;
  424. position=DeleteStack();
  425. row=position.row;
  426. col=position.col;
  427. this->dir=position.dir;
  428. ::pos[row][col]++;
  430. int row1,col1,next_row1,next_col1;
  431. element position1;
  433. while(1)
  434. {
  435. int t=0;
  436. position1=temp.DeleteStack();
  437. row1=position1.row;
  438. col1=position1.col;
  439. temp.dir=position1.dir;
  440. while(t<4)
  441. {
  442. temp.dir=temp.dir%4;
  443. next_row1=row1+move[temp.dir].vert;
  444. next_col1=col1+move[temp.dir].horiz;
  445. if(!maze[next_row1][next_col1]&&!classmark[next_row1][next_col1]&&!mark[next_row1][next_col1])
  446. {
  447. return  false;
  448. }
  449. temp.dir++;
  450. t++;
  451. }
  452. ::mark[row1][col1]=true;
  453. ::markall[row1][col1]=UNACCESSABLE;
  454. }
  456. return false;
  457. }
  458. }
  459. }
  461. return false;
  462. }
  464. int Stack::HumanSearchPathStepByStep(int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY])
  465. {
  466. while(dir<4&&!found)
  467. {
  468. next_row=row+move[dir].vert;
  469. next_col=col+move[dir].horiz;
  470. if(next_row==EXIT_ROW&&next_col==EXIT_COL)
  471. {
  472. found=true;
  473. classmark[next_row][next_col]=true;
  474. ::wild[next_row][next_col]=false;
  475. ::pos[next_row][next_col]++;
  476. ::pos[row][col]--;
  478. position.row=row;
  479. position.col=col;
  480. position.dir=--dir;
  481. AddStack(position);
  482. row=next_row;
  483. col=next_col;
  484. dir=0;
  485. AddStack(row,col,dir);
  486. count++;
  488. }
  489. else
  490. {
  491. if(!maze[next_row][next_col]&&!classmark[next_row][next_col]&&!mark[next_row][next_col])
  492. {
  493. classmark[next_row][next_col]=true;
  494. ::pos[row][col]--;
  495. ::pos[next_row][next_col]++;
  496. ::wild[next_row][next_col]=false;
  498. position.row=row;
  499. position.col=col;
  500. position.dir=++dir;
  501. AddStack(position);
  502. row=next_row;
  503. col=next_col;
  504. dir=0;
  505. count++;
  506. return 0;
  507. }
  508. else
  509. {
  510. ++dir;
  511. if(dir==4)
  512. {
  513. if(!Empty()&&!found)
  514. {
  516. Stack temp;
  517. temp=*this;
  519. ::mark[row][col]=true;// tell others donot take this way;
  520. count++;
  521. ::pos[row][col]--;
  522. ::markall[row][col]=UNACCESSABLE;
  523. position=DeleteStack();
  524. row=position.row;
  525. col=position.col;
  526. dir=position.dir;
  527. ::pos[row][col]++;
  530. int row1,col1,next_row1,next_col1;
  531. element position1;
  532. while(1)
  533. {
  534. int t=0;
  535. position1=temp.DeleteStack();
  536. row1=position1.row;
  537. col1=position1.col;
  538. temp.dir=position1.dir;
  540. while(t<4)
  541. {
  542. temp.dir++;
  543. temp.dir=temp.dir%4;
  544. next_row1=row1+move[temp.dir].vert;
  545. next_col1=col1+move[temp.dir].horiz;
  546. if(!maze[next_row1][next_col1]&&!classmark[next_row1][next_col1]&&!mark[next_row1][next_col1])
  547. {
  548. return 0;
  549. }
  550. t++;
  551. }
  552. ::mark[row1][col1]=true;
  553. ::markall[row1][col1]=UNACCESSABLE;
  554. }
  556. return 0;
  557. }
  558. else
  559. return -1;
  560. }
  561. }
  562. }
  563. }
  565. if(found)
  566. {
  567. return count;
  568. }
  569. else
  570. {
  571. return 0;
  572. }
  574. }
  577. int Stack::SearchPathStepByStep(int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY])
  578. {
  579. while(dir<4&&!found)
  580. {
  581. next_row=row+move[dir].vert;
  582. next_col=col+move[dir].horiz;
  583. if(next_row==EXIT_ROW&&next_col==EXIT_COL)
  584. {
  585. found=true;
  586. classmark[next_row][next_col]=true;
  587. ::wild[next_row][next_col]=false;
  588. ::pos[next_row][next_col]++;
  589. ::pos[row][col]--;
  591. position.row=row;
  592. position.col=col;
  593. position.dir=--dir;
  594. AddStack(position);
  595. row=next_row;
  596. col=next_col;
  597. dir=0;
  598. AddStack(row,col,dir);
  599. count++;
  601. }
  602. else
  603. {
  604. if(!maze[next_row][next_col]&&!classmark[next_row][next_col]&&!mark[next_row][next_col])
  605. {
  606. classmark[next_row][next_col]=true;
  607. ::pos[row][col]--;
  608. ::pos[next_row][next_col]++;
  609. ::wild[next_row][next_col]=false;
  611. position.row=row;
  612. position.col=col;
  613. position.dir=++dir;
  614. AddStack(position);
  615. row=next_row;
  616. col=next_col;
  617. dir=0;
  618. count++;
  619. return 0;
  620. }
  621. else
  622. {
  623. ++dir;
  624. if(dir==4)
  625. {
  626. if(!Empty()&&!found)
  627. {
  628. ::mark[row][col]=true;// tell others donot take this way;
  629. count++;
  630. ::pos[row][col]--;
  631. ::markall[row][col]=UNACCESSABLE;
  632. position=DeleteStack();
  633. row=position.row;
  634. col=position.col;
  635. dir=position.dir;
  636. ::pos[row][col]++;
  637. return 0;
  638. }
  639. else
  640. return -1;
  641. }
  642. }
  643. }
  644. }
  646. if(found)
  647. {
  648. return count;
  649. }
  650. else
  651. {
  652. return 0;
  653. }
  655. }
  659. int Stack::SearchPathStepByStepRandom()
  660. {
  661. int num=0;
  662. int method=rand()%2;
  663. dir=rand()%4;
  664. while(!found)
  665. {
  666. next_row=row+move[dir].vert;
  667. next_col=col+move[dir].horiz;
  668. if(next_row==EXIT_ROW&&next_col==EXIT_COL)
  669. {
  670. ::found=true;
  671. classmark[next_row][next_col]=true;
  672. ::pos[next_row][next_col]++;
  673. ::pos[row][col]--;
  675. position.row=row;
  676. position.col=col;
  677. position.dir=--dir;
  678. AddStack(position);
  679. row=next_row;
  680. col=next_col;
  681. dir=0;
  682. AddStack(row,col,dir);
  683. count++;
  685. }
  686. else
  687. {
  688. if(!maze[next_row][next_col]&&!classmark[next_row][next_col])
  689. {
  690. classmark[next_row][next_col]=true;
  691. ::pos[row][col]--;
  692. ::pos[next_row][next_col]++;
  693. position.row=row;
  694. position.col=col;
  695. position.dir=++dir;
  696. AddStack(position);
  697. row=next_row;
  698. col=next_col;
  699. dir=0;
  700. count++;
  701. return 0;
  702. }
  703. else
  704. {
  705. ++num;
  706. if(num==4)
  707. {
  708. if(!Empty()&&!found)
  709. {
  710. count++;
  711. ::pos[row][col]--;
  712. position=DeleteStack();
  713. row=position.row;
  714. col=position.col;
  715. dir=position.dir;
  716. ::pos[row][col]++;
  717. return 0;
  718. }
  719. else
  720. return -1;
  721. }
  722. }
  723. }
  724. if(method==0)
  725. dir=(++dir)%4;
  726. if(method==1)
  727. dir=((--dir)+4)%4;
  728. }
  730. if(found)
  731. {
  732. return count;
  733. }
  734. else
  735. {
  736. return 0;
  737. }
  739. }
  742. void SimpleMaze()
  743. {
  744. int i=1,j=1;
  745. maze[i][j]=0;
  746. int k;
  747. while(i!=EXIT_ROW||j!=EXIT_COL)
  748. {
  749. if(i==EXIT_ROW)
  750. {
  751. while(j!=EXIT_COL)
  752. maze[i][++j]=0;
  753. break;
  754. }
  755. if(j==EXIT_COL)
  756. {
  757. while(i!=EXIT_ROW)
  758. maze[++i][j]=0;
  759. break;
  760. }
  761. k=rand()%2;
  762. if(k==0)
  763. {
  764. i++;
  765. maze[i][j]=0;
  766. continue;
  767. }
  768. if(k==1)
  769. {
  770. j++;
  771. maze[i][j]=0;
  772. continue;
  773. }
  774. }
  776. }
  777. void GenerateMaze()
  778. {
  779. int i,j;
  780. int i1,j1;
  781. for(i=0;i<SIZEX_MAZE;i++)
  782. for(j=0;j<SIZEY_MAZE;j++)
  783. maze[i][j]=1;
  784. SimpleMaze();
  785. for(i=2;i<SIZEX_MAZE-2;i++)
  786. for(j=2;j<SIZEY_MAZE-2;j++)
  787. {
  788. if(Square1(i,j))
  789. {
  790. i1=i-rand()%2;
  791. j1=j-rand()%2;
  792. maze[i1][j1]=0;
  793. }
  794. }
  796. Stack _stack;
  797. if(SearchPath(_stack)==0)
  798. {
  799.    SimpleMaze();
  800. }
  802. }
  803. void ShowMaze()
  804. {
  805. int i=0,j=0;
  806. for(i=1;i<SIZEX_MAZE-1;i++)
  807. {
  808. for(j=1;j<SIZEY_MAZE-1;j++)
  809. cout<<maze[i][j]<<" ";
  810. cout<<endl;   
  811. }
  813. }
  814. void InitMark()
  815. {
  816. int i,j;
  817. for(i=0;i<CONST_MAZEX;i++)
  818. for(j=0;j<CONST_MAZEY;j++)
  819. {
  820. wild[i][j]=true;
  821. mark[i][j]=false;
  822. if(maze[i][j]==1)
  823. markall[i][j]=UNACCESSABLE;
  824. else
  825. markall[i][j]=0;
  826. pos[i][j]=0;
  827. }
  828. move[0].GetValue(-1,0);
  829. move[1].GetValue(0,1);
  830. move[2].GetValue(1,0);
  831. move[3].GetValue(0,-1);
  832. }
  834. long SearchPath(Stack & _stack)
  835. {
  836. int row,col,next_row,next_col,dir;
  837. long count=0;
  838. bool found=false;
  839. element position;
  840. InitMark();
  841. mark[1][1]=true;
  842. _stack.AddStack(1,1,1);
  843. while(!_stack.Empty()&&!found)
  844. {
  845. position=_stack.DeleteStack();
  846. row=position.row;
  847. col=position.col;
  848. dir=position.dir;
  849. while(dir<4&&!found)
  850. {
  852. next_row=row+move[dir].vert;
  853. next_col=col+move[dir].horiz;
  854. if(next_row==EXIT_ROW&&next_col==EXIT_COL)
  855. found=true;
  856. else
  857. if(!maze[next_row][next_col]&&!mark[next_row][next_col])
  858. {
  859. mark[next_row][next_col]=1;
  860. position.row=row;
  861. position.col=col;
  862. position.dir=++dir;
  863. _stack.AddStack(position);
  864. row=next_row;
  865. col=next_col;
  866. dir=0;
  867. count++;
  869. }
  870. else
  871. ++dir;
  872. }
  873. }
  874. if(found)
  875. {
  876. return count;
  877. }
  878. else
  879. return 0;
  880. }
  883. void InitAll()
  884. {
  885. GenerateMaze();
  886. InitMark();
  887. }
  889. int Min(int x,int y ,int z,int w,bool xi,bool yi,bool zi,bool wi)
  890. {
  891. int m=x*y*z*w;
  892. int count;
  893. if(m==0)
  894. {
  895. count=0;
  896. if(x==0&&xi)
  897. count+=1;
  898. if(y==0&&yi)
  899. count+=2;
  900. if(z==0&&zi)
  901. count+=4;
  902. if(w==0&&wi)
  903. count+=8;
  904. return count;
  905. }
  906. return 0;
  907. // return 0 shows that it should do as priority and not the chance
  909. //如果这个时候有两个路口有人，一个路口没有人进去过，那么全塞到这个路口里面去
  910. }
  912. // hxm begin
  913. void SubAllocate(int count,Stack _stackarray[],int n,element position,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY],int &tag)
  914. // hxm end
  915. {
  916. int max,i;
  917. int num;
  918. int dir;
  919. int x=position.row;
  920. int y=position.col;
  921. int turn;
  923. switch(count)
  924. {
  925. case 1: // all go to (x-1,y)
  926. for(i=0;i<n;i++)
  927. {
  928. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  929. {
  931. dir=0;
  932. if(tag==4)
  933. {
  934. _stackarray[i].TestDirection(dir,markall,mark,pos);
  935. tag=0;
  936. return ;
  937. }
  938. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  939. {
  940. max=markall[x+1][y];
  941. if(max<markall[x][y-1])
  942. { max=markall[x][y-1];}
  943. if(max<markall[x][y+1])
  944. { max=markall[x][y+1];}
  945. num=0;
  946. if(max==markall[x+1][y]) num+=2;
  947. if(max==markall[x][y-1]) num+=4;
  948. if(max==markall[x][y+1]) num+=8;
  949. tag++;
  950. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  951. }
  952. }
  953. }
  954. break;
  955. case 2: // all go to (x+1,y)
  956. for(i=0;i<n;i++)
  957. {
  958. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  959. {
  960. dir=2;
  961. if(tag==4)
  962. {
  963. _stackarray[i].TestDirection(dir,markall,mark,pos);
  964. tag=0;
  965. return ;
  966. }
  967. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  968. {
  969. max=markall[x-1][y];
  970. if(max<markall[x][y-1])
  971. { max=markall[x][y-1];}
  972. if(max<markall[x][y+1])
  973. { max=markall[x][y+1];}
  974. num=0;
  975. if(max==markall[x-1][y]) num+=1;
  976. if(max==markall[x][y-1]) num+=4;
  977. if(max==markall[x][y+1]) num+=8;
  978. tag++;
  979. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  980. }
  981. }
  982. }
  983. break;
  984. case 3: // all to (x-1,y) and (x+1,y)
  985. turn=0;
  986. for(i=0;i<n;i++)
  987. {
  988. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  989. {
  990. if(turn==0)
  991. {
  992. dir=0;
  993. if(tag==4)
  994. {
  995. _stackarray[i].TestDirection(dir,markall,mark,pos);
  996. tag=0;
  997. return ;
  998. }
  999. turn=1;
  1000. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1001. {
  1002. dir=2;
  1003. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1004. {
  1005. turn=0;
  1006. max=markall[x][y-1];
  1007. if(max<markall[x][y+1])
  1008. { max=markall[x][y+1];}
  1009. num=0;
  1010. if(max==markall[x][y-1]) num+=4;
  1011. if(max==markall[x][y+1]) num+=8;
  1012. tag++;
  1013. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1014. }
  1015. }
  1016. }
  1017. else
  1018. {
  1019. dir=2;
  1020. if(tag==4)
  1021. {
  1022. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1023. tag=0;
  1024. return ;
  1025. }
  1026. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1027. {
  1028. dir=0;
  1029. turn=0;
  1030. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1031. {
  1032. turn=1;
  1033. max=markall[x][y-1];
  1034. if(max<markall[x][y+1])
  1035. { max=markall[x][y+1] ;}
  1036. num=0;
  1037. if(max==markall[x][y-1]) num+=4;
  1038. if(max==markall[x][y+1]) num+=8;
  1039. tag++;
  1040. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1041. }
  1042. }
  1043. }
  1044. }
  1045. }
  1046. break;
  1048. case 4:
  1049. // all go to (x,y-1)
  1050. for(i=0;i<n;i++)
  1051. {
  1052. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1053. {
  1054. dir=3;
  1055. if(tag==4)
  1056. {
  1057. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1058. tag=0;
  1059. return ;
  1060. }
  1061. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1062. {
  1063. max=markall[x-1][y];
  1064. if(max<markall[x+1][y])
  1065. { max=markall[x+1][y] ;}
  1066. if(max<markall[x][y+1])
  1067. { max=markall[x][y+1] ;}
  1068. num=0;
  1069. if(max==markall[x-1][y]) num+=1;
  1070. if(max==markall[x+1][y]) num+=2;
  1071. if(max==markall[x][y+1]) num+=8;
  1072. tag++;
  1073. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1074. }
  1075. }
  1076. }
  1077. break;
  1078. case 5: // all go to (x-1,y) and (x,y-1)
  1079. turn=0;
  1080. for(i=0;i<n;i++)
  1081. {
  1082. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1083. {
  1084. if(turn==0)
  1085. {
  1086. dir=0;
  1087. if(tag==4)
  1088. {
  1089. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1090. tag=0;
  1091. return ;
  1092. }
  1093. turn=1;
  1094. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1095. {
  1096. dir=3;
  1097. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1098. {
  1099. turn=0;
  1100. max=markall[x+1][y];
  1101. if(max<markall[x][y+1])
  1102. { max=markall[x][y+1] ;}
  1103. num=0;
  1104. if(max==markall[x+1][y]) num+=2;
  1105. if(max==markall[x][y+1]) num+=8;
  1106. tag++;
  1107. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1108. }
  1109. }
  1110. }
  1111. else
  1112. {
  1113. dir=3;
  1114. if(tag==4)
  1115. {
  1116. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1117. tag=0;
  1118. return ;
  1119. }
  1120. turn=0;
  1121. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1122. {
  1123. dir=0;
  1125. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1126. {
  1127. turn=1;
  1128. max=markall[x+1][y];
  1129. if(max<markall[x][y+1])
  1130. { max=markall[x][y+1] ;}
  1131. num=0;
  1132. if(max==markall[x+1][y]) num+=2;
  1133. if(max==markall[x][y+1]) num+=8;
  1134. tag++;
  1135. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1136. }
  1137. }
  1138. }
  1139. }
  1140. }
  1141. break;
  1142. case 6: // all go to (x+1,y) and (x,y-1)
  1143. turn=0;
  1144. for(i=0;i<n;i++)
  1145. {
  1146. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1147. {
  1148. if(turn==0)
  1149. {
  1150. turn=1;
  1151. dir=2;
  1152. if(tag==4)
  1153. {
  1154. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1155. tag=0;
  1156. return ;
  1157. }
  1158. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1159. {
  1160. dir=3;
  1161. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1162. {
  1163. turn=0;
  1164. max=markall[x-1][y];
  1165. if(max<markall[x][y+1])
  1166. { max=markall[x][y+1] ;}
  1167. num=0;
  1168. if(max==markall[x-1][y]) num+=1;
  1169. if(max==markall[x][y+1]) num+=8;
  1170. tag++;
  1171. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1172. }
  1173. }
  1174. }
  1175. else
  1176. {
  1177. dir=3;
  1178. if(tag==4)
  1179. {
  1180. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1181. tag=0;
  1182. return ;
  1183. }
  1184. turn=0;
  1185. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1186. {
  1187. dir=2;
  1188. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1189. {
  1190. turn=1;
  1191. max=markall[x-1][y];
  1192. if(max<markall[x][y+1])
  1193. { max=markall[x][y+1] ;}
  1194. num=0;
  1195. if(max==markall[x-1][y]) num+=1;
  1196. if(max==markall[x][y+1]) num+=8;
  1197. tag++;
  1198. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1199. }
  1200. }
  1201. }
  1202. }
  1203. }
  1204. break;
  1205. case 7:
  1206. // all go to (x-1,y) and (x+1,y) and (x,y-1)
  1207. turn=0;
  1208. for(i=0;i<n;i++)
  1209. {
  1210. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1211. {
  1212. if(tag==4)
  1213. {
  1214. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1215. tag=0;
  1216. return ;
  1217. }
  1218. switch(turn)
  1219. {
  1220. case 0:
  1221. dir=0;
  1222. turn=1;
  1223. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1224. {
  1225. dir=2;
  1226. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1227. {
  1228. dir=3;
  1229. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1230. {
  1231. turn=0;
  1232. dir=1;
  1233. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1234. {
  1235. dir=0;
  1236. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1238. }
  1239. }
  1240. }
  1241. }
  1242. break;
  1243. case 1:
  1244. dir=2;
  1245. turn=2;
  1246. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1247. {
  1248. dir=3;
  1249. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1250. {
  1251. dir=0;
  1252. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1253. {
  1254. turn=1;
  1255. dir=1;
  1256. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1257. {
  1258. dir=0;
  1259. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1261. }
  1262. }
  1263. }
  1264. }
  1265. break;
  1266. case 2:
  1267. dir=3;
  1268. turn=0;
  1269. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1270. {
  1271. dir=0;
  1272. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1273. {
  1274. dir=2;
  1275. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1276. {
  1277. turn=2;
  1278. dir=1;
  1279. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1280. {
  1281. dir=0;
  1282. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1284. }
  1285. }
  1286. }
  1287. }
  1288. break;
  1289. }
  1290. }
  1291. }
  1292. break;
  1294. case 8:
  1295. // all go to (x,y+1)
  1296. for(i=0;i<n;i++)
  1297. {
  1298. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1299. {
  1300. dir=1;
  1301. if(tag==4)
  1302. {
  1303. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1304. tag=0;
  1305. return ;
  1306. }
  1307. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1308. {
  1309. max=markall[x-1][y];
  1310. if(max<markall[x+1][y])
  1311. { max=markall[x+1][y];}
  1312. if(max<markall[x][y-1])
  1313. { max=markall[x][y-1];}
  1314. num=0;
  1315. if(max==markall[x-1][y]) num+=1;
  1316. if(max==markall[x+1][y]) num+=2;
  1317. if(max==markall[x][y-1]) num+=4;
  1318. tag++;
  1319. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1321. }
  1322. }
  1323. }
  1324. break;
  1326. case 9:
  1327. // all go to (x-1,y) and (x,y+1)
  1328. turn=0;
  1329. for(i=0;i<n;i++)
  1330. {
  1331. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1332. {
  1333. dir=0;
  1334. if(tag==4)
  1335. {
  1336. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1337. tag=0;
  1338. return ;
  1339. }
  1340. if(turn==0)
  1341. {
  1342. turn=1;
  1343. dir=0;
  1344. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1345. {
  1346. dir=1;
  1347. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1348. {
  1349. turn=0;
  1350. max=markall[x+1][y];
  1351. if(max<markall[x][y-1])
  1352. { max=markall[x][y-1] ;}
  1353. num=0;
  1354. if(max==markall[x+1][y]) num+=2;
  1355. if(max==markall[x][y-1]) num+=4;
  1356. tag++;
  1357. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1358. }
  1359. }
  1360. }
  1361. else
  1362. {
  1363. dir=1;
  1364. turn=0;
  1365. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1366. {
  1367. dir=0;
  1368. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1369. {
  1370. turn=1;
  1371. max=markall[x+1][y];
  1372. if(max<markall[x][y-1])
  1373. { max=markall[x][y-1];}
  1374. num=0;
  1375. if(max==markall[x+1][y]) num+=2;
  1376. if(max==markall[x][y-1]) num+=4;
  1377. tag++;
  1378. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1379. }
  1380. }
  1381. }
  1382. }
  1383. }
  1385. break;
  1386. case 10:
  1387. // all go to (x+1,y) and (x,y+1)
  1388. turn=0;
  1389. for(i=0;i<n;i++)
  1390. {
  1392. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1393. {
  1394. dir=0;
  1395. if(tag==4)
  1396. {
  1397. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1398. tag=0;
  1399. return ;
  1400. }
  1401. if(turn==0)
  1402. {
  1403. turn=1;
  1404. dir=2;
  1405. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1406. {
  1407. dir=1;
  1408. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1409. {
  1410. turn=0;
  1411. max=markall[x-1][y];
  1412. if(max<markall[x][y-1])
  1413. { max=markall[x][y-1] ;}
  1414. num=0;
  1415. if(max==markall[x-1][y]) num+=1;
  1416. if(max==markall[x][y-1]) num+=4;
  1417. tag++;
  1418. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1419. }
  1420. }
  1421. }
  1422. else
  1423. {
  1424. dir=1;
  1425. turn=0;
  1426. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1427. {
  1428. dir=0;
  1429. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1430. {
  1431. turn=1;
  1432. max=markall[x+1][y];
  1433. if(max<markall[x][y-1])
  1434. { max=markall[x][y-1] ;}
  1435. num=0;
  1436. if(max==markall[x+1][y]) num+=2;
  1437. if(max==markall[x][y-1]) num+=4;
  1438. tag++;
  1439. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1440. }
  1441. }
  1442. }
  1443. }
  1444. }
  1446. break;
  1447. case 11:
  1448. // all go to (x-1,y) and (x+1,y) and (x,y+1)
  1449. turn=0;
  1450. for(i=0;i<n;i++)
  1451. {
  1452. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1453. {
  1454. dir=0;
  1455. if(tag==4)
  1456. {
  1457. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1458. tag=0;
  1459. return ;
  1460. }
  1461. switch(turn)
  1462. {
  1463. case 0:
  1464. dir=0;
  1465. turn=1;
  1466. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1467. {
  1468. dir=2;
  1469. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1470. {
  1471. dir=1;
  1472. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1473. {
  1474. turn=0;
  1475. dir=3;
  1476. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1477. {
  1478. dir=0;
  1479. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1481. }
  1482. }
  1483. }
  1484. }
  1485. break;
  1486. case 1:
  1487. dir=2;
  1488. turn=2;
  1489. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1490. {
  1491. dir=1;
  1492. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1493. {
  1494. dir=0;
  1495. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1496. {
  1497. turn=1;
  1498. dir=3;
  1499. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1500. {
  1501. dir=0;
  1502. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1504. }
  1505. }
  1506. }
  1507. }
  1508. break;
  1509. case 2:
  1510. dir=1;
  1511. turn=0;
  1512. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1513. {
  1514. dir=0;
  1515. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1516. {
  1517. dir=2;
  1518. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1519. {
  1520. turn=2;
  1521. dir=3;
  1522. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1523. {
  1524. dir=0;
  1525. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1527. }
  1528. }
  1529. }
  1530. }
  1531. break;
  1532. }
  1533. }
  1534. }
  1535. break;
  1536. case 12:
  1537. // all go to (x,y-1) and (x,y+1)
  1538. turn=0;
  1539. for(i=0;i<n;i++)
  1540. {
  1541. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1542. {
  1543. dir=0;
  1544. if(tag==4)
  1545. {
  1546. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1547. tag=0;
  1548. return ;
  1549. }
  1550. if(turn==0)
  1551. {
  1552. turn=1;
  1553. dir=3;
  1554. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1555. {
  1556. dir=1;
  1557. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1558. {
  1559. turn=0;
  1560. max=markall[x-1][y];
  1561. if(max<markall[x+1][y])
  1562. { max=markall[x+1][y] ;}
  1563. num=0;
  1564. if(max==markall[x-1][y]) num+=1;
  1565. if(max==markall[x+1][y]) num+=2;
  1566. tag++;
  1567. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1568. }
  1569. }
  1570. }
  1571. else
  1572. {
  1573. dir=1;
  1574. turn=0;
  1575. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1576. {
  1577. dir=3;
  1578. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1579. {
  1580. turn=1;
  1581. max=markall[x-1][y];
  1582. if(max<markall[x+1][y])
  1583. { max=markall[x+1][y] ;}
  1584. num=0;
  1585. if(max==markall[x-1][y]) num+=1;
  1586. if(max==markall[x+1][y]) num+=2;
  1587. tag++;
  1588. SubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1589. }
  1590. }
  1591. }
  1592. }
  1593. }
  1595. break;
  1596. case 13:
  1597. // all go to (x-1,y) and (x,y-1) and (x,y+1)
  1598. turn=0;
  1599. for(i=0;i<n;i++)
  1600. {
  1601. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1602. {
  1603. dir=0;
  1604. if(tag==4)
  1605. {
  1606. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1607. tag=0;
  1608. return ;
  1609. }
  1610. switch(turn)
  1611. {
  1612. case 0:
  1613. dir=0;
  1614. turn=1;
  1615. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1616. {
  1617. dir=3;
  1618. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1619. {
  1620. dir=1;
  1621. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1622. {
  1623. turn=0;
  1624. dir=2;
  1625. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1626. {
  1627. dir=0;
  1628. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1630. }
  1631. }
  1632. }
  1633. }
  1634. break;
  1635. case 1:
  1636. dir=3;
  1637. turn=2;
  1638. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1639. {
  1640. dir=1;
  1641. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1642. {
  1643. dir=0;
  1644. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1645. {
  1646. turn=1;
  1647. dir=2;
  1648. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1649. {
  1650. dir=0;
  1651. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1653. }
  1654. }
  1655. }
  1656. }
  1657. break;
  1658. case 2:
  1659. dir=1;
  1660. turn=0;
  1661. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1662. {
  1663. dir=0;
  1664. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1665. {
  1666. dir=3;
  1667. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1668. {
  1669. turn=2;
  1670. dir=2;
  1671. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1672. {
  1673. dir=0;
  1674. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1676. }
  1677. }
  1678. }
  1679. }
  1680. break;
  1681. }
  1682. }
  1683. }
  1684. break;
  1685. case 14:
  1686. // all go to (x+1,y) and (x,y-1) and (x,y+1)
  1687. turn=0;
  1688. for(i=0;i<n;i++)
  1689. {
  1690. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1691. {
  1692. dir=0;
  1693. if(tag==4)
  1694. {
  1695. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1696. tag=0;
  1697. return ;
  1698. }
  1699. switch(turn)
  1700. {
  1701. case 0:
  1702. dir=2;
  1703. turn=1;
  1704. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1705. {
  1706. dir=3;
  1707. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1708. {
  1709. dir=1;
  1710. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1711. {
  1712. turn=0;
  1713. dir=0;
  1714. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1715. {
  1716. dir=0;
  1717. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1719. }
  1720. }
  1721. }
  1722. }
  1723. break;
  1724. case 1:
  1725. dir=3;
  1726. turn=2;
  1727. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1728. {
  1729. dir=1;
  1730. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1731. {
  1732. dir=1;
  1733. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1734. {
  1735. turn=1;
  1736. dir=2;
  1737. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1738. {
  1739. dir=0;
  1740. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1742. }
  1743. }
  1744. }
  1745. }
  1746. break;
  1747. case 2:
  1748. dir=1;
  1749. turn=0;
  1750. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1751. {
  1752. dir=2;
  1753. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1754. {
  1755. dir=3;
  1756. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1757. {
  1758. turn=2;
  1759. dir=0;
  1760. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1761. {
  1762. dir=0;
  1763. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1765. }
  1766. }
  1767. }
  1768. }
  1769. break;
  1770.      
  1771. }
  1772. }
  1773. }
  1774. break;
  1775. case 15: // all go to (x-1,y) and (x+1,y) and (x,y-1) and (x,y+1)
  1776. turn=0;
  1777. for(i=0;i<n;i++)
  1778. {
  1779. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1780. {
  1781. dir=0;
  1782. if(tag==4)
  1783. {
  1784. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1785. tag=0;
  1786. return ;
  1787. }
  1788. switch(turn)
  1789. {
  1790. case 0:
  1791. dir=0;
  1792. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1793. turn=1;
  1794. break;
  1795. case 1:
  1796. dir=1;
  1797. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1798. turn=2;
  1799. break;
  1800. case 2:
  1801. dir=2;
  1802. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1803. turn=3;
  1804. break;
  1805. case 3:
  1806. dir=3;
  1807. _stackarray[i].TestDirection(dir,markall,mark,pos);
  1808. turn=0;
  1809. break;
  1810. }
  1811. }
  1812. }
  1813. break;
  1814. default:
  1815. break;
  1816. }
  1818. }
  1820. void HumanSubAllocate(int count,Stack _stackarray[],int n,element position,int markall[CONST_MAZEX][CONST_MAZEY],bool mark[CONST_MAZEX][CONST_MAZEY],int pos[CONST_MAZEX][CONST_MAZEY],int &tag)
  1821. // hxm end
  1822. {
  1823. int max,i;
  1824. int num;
  1825. int dir;
  1826. int x=position.row;
  1827. int y=position.col;
  1828. int turn;
  1830. switch(count)
  1831. {
  1832. case 1: // all go to (x-1,y)
  1833. for(i=0;i<n;i++)
  1834. {
  1835. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1836. {
  1838. dir=0;
  1839. if(tag==4)
  1840. {
  1841. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  1842. tag=0;
  1843. return ;
  1844. }
  1845. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1846. {
  1847. max=markall[x+1][y];
  1848. if(max<markall[x][y-1])
  1849. { max=markall[x][y-1];}
  1850. if(max<markall[x][y+1])
  1851. { max=markall[x][y+1];}
  1852. num=0;
  1853. if(max==markall[x+1][y]) num+=2;
  1854. if(max==markall[x][y-1]) num+=4;
  1855. if(max==markall[x][y+1]) num+=8;
  1856. tag++;
  1857. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1858. }
  1859. }
  1860. }
  1861. break;
  1862. case 2: // all go to (x+1,y)
  1863. for(i=0;i<n;i++)
  1864. {
  1865. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1866. {
  1867. dir=2;
  1868. if(tag==4)
  1869. {
  1870. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  1871. tag=0;
  1872. return ;
  1873. }
  1874. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1875. {
  1876. max=markall[x-1][y];
  1877. if(max<markall[x][y-1])
  1878. { max=markall[x][y-1];}
  1879. if(max<markall[x][y+1])
  1880. { max=markall[x][y+1];}
  1881. num=0;
  1882. if(max==markall[x-1][y]) num+=1;
  1883. if(max==markall[x][y-1]) num+=4;
  1884. if(max==markall[x][y+1]) num+=8;
  1885. tag++;
  1886. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1887. }
  1888. }
  1889. }
  1890. break;
  1891. case 3: // all to (x-1,y) and (x+1,y)
  1892. turn=0;
  1893. for(i=0;i<n;i++)
  1894. {
  1895. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1896. {
  1897. if(turn==0)
  1898. {
  1899. dir=0;
  1900. if(tag==4)
  1901. {
  1902. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  1903. tag=0;
  1904. return ;
  1905. }
  1906. turn=1;
  1907. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1908. {
  1909. dir=2;
  1910. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1911. {
  1912. turn=0;
  1913. max=markall[x][y-1];
  1914. if(max<markall[x][y+1])
  1915. { max=markall[x][y+1];}
  1916. num=0;
  1917. if(max==markall[x][y-1]) num+=4;
  1918. if(max==markall[x][y+1]) num+=8;
  1919. tag++;
  1920. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1921. }
  1922. }
  1923. }
  1924. else
  1925. {
  1926. dir=2;
  1927. if(tag==4)
  1928. {
  1929. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  1930. tag=0;
  1931. return ;
  1932. }
  1933. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1934. {
  1935. dir=0;
  1936. turn=0;
  1937. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1938. {
  1939. turn=1;
  1940. max=markall[x][y-1];
  1941. if(max<markall[x][y+1])
  1942. { max=markall[x][y+1] ;}
  1943. num=0;
  1944. if(max==markall[x][y-1]) num+=4;
  1945. if(max==markall[x][y+1]) num+=8;
  1946. tag++;
  1947. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1948. }
  1949. }
  1950. }
  1951. }
  1952. }
  1953. break;
  1955. case 4:
  1956. // all go to (x,y-1)
  1957. for(i=0;i<n;i++)
  1958. {
  1959. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1960. {
  1961. dir=3;
  1962. if(tag==4)
  1963. {
  1964. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  1965. tag=0;
  1966. return ;
  1967. }
  1968. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  1969. {
  1970. max=markall[x-1][y];
  1971. if(max<markall[x+1][y])
  1972. { max=markall[x+1][y] ;}
  1973. if(max<markall[x][y+1])
  1974. { max=markall[x][y+1] ;}
  1975. num=0;
  1976. if(max==markall[x-1][y]) num+=1;
  1977. if(max==markall[x+1][y]) num+=2;
  1978. if(max==markall[x][y+1]) num+=8;
  1979. tag++;
  1980. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  1981. }
  1982. }
  1983. }
  1984. break;
  1985. case 5: // all go to (x-1,y) and (x,y-1)
  1986. turn=0;
  1987. for(i=0;i<n;i++)
  1988. {
  1989. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  1990. {
  1991. if(turn==0)
  1992. {
  1993. dir=0;
  1994. if(tag==4)
  1995. {
  1996. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  1997. tag=0;
  1998. return ;
  1999. }
  2000. turn=1;
  2001. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2002. {
  2003. dir=3;
  2004. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2005. {
  2006. turn=0;
  2007. max=markall[x+1][y];
  2008. if(max<markall[x][y+1])
  2009. { max=markall[x][y+1] ;}
  2010. num=0;
  2011. if(max==markall[x+1][y]) num+=2;
  2012. if(max==markall[x][y+1]) num+=8;
  2013. tag++;
  2014. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2015. }
  2016. }
  2017. }
  2018. else
  2019. {
  2020. dir=3;
  2021. if(tag==4)
  2022. {
  2023. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2024. tag=0;
  2025. return ;
  2026. }
  2027. turn=0;
  2028. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2029. {
  2030. dir=0;
  2032. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2033. {
  2034. turn=1;
  2035. max=markall[x+1][y];
  2036. if(max<markall[x][y+1])
  2037. { max=markall[x][y+1] ;}
  2038. num=0;
  2039. if(max==markall[x+1][y]) num+=2;
  2040. if(max==markall[x][y+1]) num+=8;
  2041. tag++;
  2042. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2043. }
  2044. }
  2045. }
  2046. }
  2047. }
  2048. break;
  2049. case 6: // all go to (x+1,y) and (x,y-1)
  2050. turn=0;
  2051. for(i=0;i<n;i++)
  2052. {
  2053. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2054. {
  2055. if(turn==0)
  2056. {
  2057. turn=1;
  2058. dir=2;
  2059. if(tag==4)
  2060. {
  2061. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2062. tag=0;
  2063. return ;
  2064. }
  2065. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2066. {
  2067. dir=3;
  2068. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2069. {
  2070. turn=0;
  2071. max=markall[x-1][y];
  2072. if(max<markall[x][y+1])
  2073. { max=markall[x][y+1] ;}
  2074. num=0;
  2075. if(max==markall[x-1][y]) num+=1;
  2076. if(max==markall[x][y+1]) num+=8;
  2077. tag++;
  2078. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2079. }
  2080. }
  2081. }
  2082. else
  2083. {
  2084. dir=3;
  2085. if(tag==4)
  2086. {
  2087. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2088. tag=0;
  2089. return ;
  2090. }
  2091. turn=0;
  2092. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2093. {
  2094. dir=2;
  2095. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2096. {
  2097. turn=1;
  2098. max=markall[x-1][y];
  2099. if(max<markall[x][y+1])
  2100. { max=markall[x][y+1] ;}
  2101. num=0;
  2102. if(max==markall[x-1][y]) num+=1;
  2103. if(max==markall[x][y+1]) num+=8;
  2104. tag++;
  2105. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2106. }
  2107. }
  2108. }
  2109. }
  2110. }
  2111. break;
  2112. case 7:
  2113. // all go to (x-1,y) and (x+1,y) and (x,y-1)
  2114. turn=0;
  2115. for(i=0;i<n;i++)
  2116. {
  2117. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2118. {
  2119. if(tag==4)
  2120. {
  2121. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2122. tag=0;
  2123. return ;
  2124. }
  2125. switch(turn)
  2126. {
  2127. case 0:
  2128. dir=0;
  2129. turn=1;
  2130. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2131. {
  2132. dir=2;
  2133. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2134. {
  2135. dir=3;
  2136. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2137. {
  2138. turn=0;
  2139. dir=1;
  2140. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2141. {
  2142. dir=0;
  2143. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2145. }
  2146. }
  2147. }
  2148. }
  2149. break;
  2150. case 1:
  2151. dir=2;
  2152. turn=2;
  2153. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2154. {
  2155. dir=3;
  2156. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2157. {
  2158. dir=0;
  2159. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2160. {
  2161. turn=1;
  2162. dir=1;
  2163. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2164. {
  2165. dir=0;
  2166. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2168. }
  2169. }
  2170. }
  2171. }
  2172. break;
  2173. case 2:
  2174. dir=3;
  2175. turn=0;
  2176. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2177. {
  2178. dir=0;
  2179. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2180. {
  2181. dir=2;
  2182. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2183. {
  2184. turn=2;
  2185. dir=1;
  2186. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2187. {
  2188. dir=0;
  2189. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2191. }
  2192. }
  2193. }
  2194. }
  2195. break;
  2196. }
  2197. }
  2198. }
  2199. break;
  2201. case 8:
  2202. // all go to (x,y+1)
  2203. for(i=0;i<n;i++)
  2204. {
  2205. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2206. {
  2207. dir=1;
  2208. if(tag==4)
  2209. {
  2210. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2211. tag=0;
  2212. return ;
  2213. }
  2214. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2215. {
  2216. max=markall[x-1][y];
  2217. if(max<markall[x+1][y])
  2218. { max=markall[x+1][y];}
  2219. if(max<markall[x][y-1])
  2220. { max=markall[x][y-1];}
  2221. num=0;
  2222. if(max==markall[x-1][y]) num+=1;
  2223. if(max==markall[x+1][y]) num+=2;
  2224. if(max==markall[x][y-1]) num+=4;
  2225. tag++;
  2226. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2228. }
  2229. }
  2230. }
  2231. break;
  2233. case 9:
  2234. // all go to (x-1,y) and (x,y+1)
  2235. turn=0;
  2236. for(i=0;i<n;i++)
  2237. {
  2238. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2239. {
  2240. dir=0;
  2241. if(tag==4)
  2242. {
  2243. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2244. tag=0;
  2245. return ;
  2246. }
  2247. if(turn==0)
  2248. {
  2249. turn=1;
  2250. dir=0;
  2251. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2252. {
  2253. dir=1;
  2254. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2255. {
  2256. turn=0;
  2257. max=markall[x+1][y];
  2258. if(max<markall[x][y-1])
  2259. { max=markall[x][y-1] ;}
  2260. num=0;
  2261. if(max==markall[x+1][y]) num+=2;
  2262. if(max==markall[x][y-1]) num+=4;
  2263. tag++;
  2264. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2265. }
  2266. }
  2267. }
  2268. else
  2269. {
  2270. dir=1;
  2271. turn=0;
  2272. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2273. {
  2274. dir=0;
  2275. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2276. {
  2277. turn=1;
  2278. max=markall[x+1][y];
  2279. if(max<markall[x][y-1])
  2280. { max=markall[x][y-1];}
  2281. num=0;
  2282. if(max==markall[x+1][y]) num+=2;
  2283. if(max==markall[x][y-1]) num+=4;
  2284. tag++;
  2285. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2286. }
  2287. }
  2288. }
  2289. }
  2290. }
  2292. break;
  2293. case 10:
  2294. // all go to (x+1,y) and (x,y+1)
  2295. turn=0;
  2296. for(i=0;i<n;i++)
  2297. {
  2299. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2300. {
  2301. dir=0;
  2302. if(tag==4)
  2303. {
  2304. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2305. tag=0;
  2306. return ;
  2307. }
  2308. if(turn==0)
  2309. {
  2310. turn=1;
  2311. dir=2;
  2312. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2313. {
  2314. dir=1;
  2315. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2316. {
  2317. turn=0;
  2318. max=markall[x-1][y];
  2319. if(max<markall[x][y-1])
  2320. { max=markall[x][y-1] ;}
  2321. num=0;
  2322. if(max==markall[x-1][y]) num+=1;
  2323. if(max==markall[x][y-1]) num+=4;
  2324. tag++;
  2325. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2326. }
  2327. }
  2328. }
  2329. else
  2330. {
  2331. dir=1;
  2332. turn=0;
  2333. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2334. {
  2335. dir=0;
  2336. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2337. {
  2338. turn=1;
  2339. max=markall[x+1][y];
  2340. if(max<markall[x][y-1])
  2341. { max=markall[x][y-1] ;}
  2342. num=0;
  2343. if(max==markall[x+1][y]) num+=2;
  2344. if(max==markall[x][y-1]) num+=4;
  2345. tag++;
  2346. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2347. }
  2348. }
  2349. }
  2350. }
  2351. }
  2353. break;
  2354. case 11:
  2355. // all go to (x-1,y) and (x+1,y) and (x,y+1)
  2356. turn=0;
  2357. for(i=0;i<n;i++)
  2358. {
  2359. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2360. {
  2361. dir=0;
  2362. if(tag==4)
  2363. {
  2364. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2365. tag=0;
  2366. return ;
  2367. }
  2368. switch(turn)
  2369. {
  2370. case 0:
  2371. dir=0;
  2372. turn=1;
  2373. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2374. {
  2375. dir=2;
  2376. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2377. {
  2378. dir=1;
  2379. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2380. {
  2381. turn=0;
  2382. dir=3;
  2383. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2384. {
  2385. dir=0;
  2386. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2388. }
  2389. }
  2390. }
  2391. }
  2392. break;
  2393. case 1:
  2394. dir=2;
  2395. turn=2;
  2396. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2397. {
  2398. dir=1;
  2399. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2400. {
  2401. dir=0;
  2402. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2403. {
  2404. turn=1;
  2405. dir=3;
  2406. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2407. {
  2408. dir=0;
  2409. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2411. }
  2412. }
  2413. }
  2414. }
  2415. break;
  2416. case 2:
  2417. dir=1;
  2418. turn=0;
  2419. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2420. {
  2421. dir=0;
  2422. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2423. {
  2424. dir=2;
  2425. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2426. {
  2427. turn=2;
  2428. dir=3;
  2429. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2430. {
  2431. dir=0;
  2432. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2434. }
  2435. }
  2436. }
  2437. }
  2438. break;
  2439. }
  2440. }
  2441. }
  2442. break;
  2443. case 12:
  2444. // all go to (x,y-1) and (x,y+1)
  2445. turn=0;
  2446. for(i=0;i<n;i++)
  2447. {
  2448. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2449. {
  2450. dir=0;
  2451. if(tag==4)
  2452. {
  2453. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2454. tag=0;
  2455. return ;
  2456. }
  2457. if(turn==0)
  2458. {
  2459. turn=1;
  2460. dir=3;
  2461. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2462. {
  2463. dir=1;
  2464. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2465. {
  2466. turn=0;
  2467. max=markall[x-1][y];
  2468. if(max<markall[x+1][y])
  2469. { max=markall[x+1][y] ;}
  2470. num=0;
  2471. if(max==markall[x-1][y]) num+=1;
  2472. if(max==markall[x+1][y]) num+=2;
  2473. tag++;
  2474. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2475. }
  2476. }
  2477. }
  2478. else
  2479. {
  2480. dir=1;
  2481. turn=0;
  2482. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2483. {
  2484. dir=3;
  2485. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2486. {
  2487. turn=1;
  2488. max=markall[x-1][y];
  2489. if(max<markall[x+1][y])
  2490. { max=markall[x+1][y] ;}
  2491. num=0;
  2492. if(max==markall[x-1][y]) num+=1;
  2493. if(max==markall[x+1][y]) num+=2;
  2494. tag++;
  2495. HumanSubAllocate(num,_stackarray,n,position,markall,mark,pos,tag);
  2496. }
  2497. }
  2498. }
  2499. }
  2500. }
  2502. break;
  2503. case 13:
  2504. // all go to (x-1,y) and (x,y-1) and (x,y+1)
  2505. turn=0;
  2506. for(i=0;i<n;i++)
  2507. {
  2508. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2509. {
  2510. dir=0;
  2511. if(tag==4)
  2512. {
  2513. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2514. tag=0;
  2515. return ;
  2516. }
  2517. switch(turn)
  2518. {
  2519. case 0:
  2520. dir=0;
  2521. turn=1;
  2522. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2523. {
  2524. dir=3;
  2525. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2526. {
  2527. dir=1;
  2528. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2529. {
  2530. turn=0;
  2531. dir=2;
  2532. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2533. {
  2534. dir=0;
  2535. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2537. }
  2538. }
  2539. }
  2540. }
  2541. break;
  2542. case 1:
  2543. dir=3;
  2544. turn=2;
  2545. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2546. {
  2547. dir=1;
  2548. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2549. {
  2550. dir=0;
  2551. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2552. {
  2553. turn=1;
  2554. dir=2;
  2555. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2556. {
  2557. dir=0;
  2558. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2560. }
  2561. }
  2562. }
  2563. }
  2564. break;
  2565. case 2:
  2566. dir=1;
  2567. turn=0;
  2568. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2569. {
  2570. dir=0;
  2571. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2572. {
  2573. dir=3;
  2574. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2575. {
  2576. turn=2;
  2577. dir=2;
  2578. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2579. {
  2580. dir=0;
  2581. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2583. }
  2584. }
  2585. }
  2586. }
  2587. break;
  2588. }
  2589. }
  2590. }
  2591. break;
  2592. case 14:
  2593. // all go to (x+1,y) and (x,y-1) and (x,y+1)
  2594. turn=0;
  2595. for(i=0;i<n;i++)
  2596. {
  2597. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2598. {
  2599. dir=0;
  2600. if(tag==4)
  2601. {
  2602. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2603. tag=0;
  2604. return ;
  2605. }
  2606. switch(turn)
  2607. {
  2608. case 0:
  2609. dir=2;
  2610. turn=1;
  2611. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2612. {
  2613. dir=3;
  2614. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2615. {
  2616. dir=1;
  2617. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2618. {
  2619. turn=0;
  2620. dir=0;
  2621. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2622. {
  2623. dir=0;
  2624. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2626. }
  2627. }
  2628. }
  2629. }
  2630. break;
  2631. case 1:
  2632. dir=3;
  2633. turn=2;
  2634. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2635. {
  2636. dir=1;
  2637. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2638. {
  2639. dir=1;
  2640. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2641. {
  2642. turn=1;
  2643. dir=2;
  2644. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2645. {
  2646. dir=0;
  2647. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2649. }
  2650. }
  2651. }
  2652. }
  2653. break;
  2654. case 2:
  2655. dir=1;
  2656. turn=0;
  2657. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2658. {
  2659. dir=2;
  2660. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2661. {
  2662. dir=3;
  2663. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2664. {
  2665. turn=2;
  2666. dir=0;
  2667. if(_stackarray[i].TestDir(dir,markall,mark,pos)==false)
  2668. {
  2669. dir=0;
  2670. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2672. }
  2673. }
  2674. }
  2675. }
  2676. break;
  2677.      
  2678. }
  2679. }
  2680. }
  2681. break;
  2682. case 15: // all go to (x-1,y) and (x+1,y) and (x,y-1) and (x,y+1)
  2683. turn=0;
  2684. for(i=0;i<n;i++)
  2685. {
  2686. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2687. {
  2688. dir=0;
  2689. if(tag==4)
  2690. {
  2691. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2692. tag=0;
  2693. return ;
  2694. }
  2695. switch(turn)
  2696. {
  2697. case 0:
  2698. dir=0;
  2699. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2700. turn=1;
  2701. break;
  2702. case 1:
  2703. dir=1;
  2704. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2705. turn=2;
  2706. break;
  2707. case 2:
  2708. dir=2;
  2709. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2710. turn=3;
  2711. break;
  2712. case 3:
  2713. dir=3;
  2714. _stackarray[i].HumanTestDirection(dir,markall,mark,pos);
  2715. turn=0;
  2716. break;
  2717. }
  2718. }
  2719. }
  2720. break;
  2721. default:
  2722. break;
  2723. }
  2725. }
  2728. void Allocate(Stack _stackarray[],int n,int type)
  2729. {
  2730. int x,y;
  2731. int count=0;
  2732. int i=0;
  2733. int dir=0;
  2734. element position;
  2735. int turn=0;
  2736. int length=0;
  2737. int countnum=0;
  2738. bool once=true;
  2740. int maze[CONST_MAZEX][CONST_MAZEY];
  2741. int markall[CONST_MAZEX][CONST_MAZEY]; // record the num of ants of go into the path
  2742. bool mark[CONST_MAZEX][CONST_MAZEY]; // record that some path is not accessable
  2743. int pos[CONST_MAZEX][CONST_MAZEY]; // record all objects position at the same time
  2744. bool wild[CONST_MAZEX][CONST_MAZEY];
  2745. Stack newStack[CONST_ANT_NUM];
  2747. ::step++;
  2749. for(i=0;i<n;i++)
  2750. newStack[i]=_stackarray[i];
  2752. for(i=0;i<CONST_MAZEX;i++)
  2753. for(int j=0;j<CONST_MAZEY;j++)
  2754. {
  2755. maze[i][j]=::maze[i][j];
  2756. markall[i][j]=::markall[i][j];
  2757. mark[i][j]=::mark[i][j];
  2758. pos[i][j]=::pos[i][j];
  2759. wild[i][j]=::wild[i][j];
  2760. }
  2763. for(x=1;x<SIZEX_MAZE-1;x++)
  2764. for(y=1;y<SIZEY_MAZE-1;y++)
  2765. {
  2766. if(pos[x][y]<=0)
  2767. continue;
  2768. else
  2769. {
  2770. position.row=x;
  2771. position.col=y;
  2772. position.dir=1;
  2774. count=Min(markall[x-1][y],markall[x+1][y],markall[x][y-1],markall[x][y+1],wild[x-1][y],
  2775. wild[x+1][y],wild[x][y-1],wild[x][y+1]);
  2777. if(count!=0)
  2778. {
  2779. switch(count)
  2780. {
  2781. case 1:
  2782. case 2:
  2783. case 4:
  2784. case 8:
  2785. {
  2786. for(i=0;i<n;i++)
  2787. {
  2788. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2789. {
  2790. if(count==1)
  2791. dir=0;   //all go to (x-1,y)
  2792. else if(count==2)
  2793. dir=2; // all go to(x+1,y)
  2794. else if(count==4)
  2795. dir=3; // all to to (x,y-1)
  2796. else if(count==8)
  2797. dir=1; // all go to (x,y+1)
  2798. newStack[i].SetDir(dir);
  2799. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2800. }
  2801. }
  2802. break;
  2803. }
  2804. case 3:
  2805. case 5:
  2806. case 6:
  2807. {
  2808. turn=0;
  2809. for(i=0;i<n;i++)
  2810. {
  2811. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2812. {
  2813. if(turn==0)
  2814. {
  2815. if(count== 3 || count ==5)
  2816. dir=0;
  2817. else if(count==6) // all go to (x+1,y) and (x,y-1)
  2818. dir=2;
  2819. newStack[i].SetDir(dir);
  2820. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2821. turn=1;
  2822. }
  2823. else
  2824. {
  2825. if(count==3)
  2826. dir=2; // all to (x-1,y) and (x+1,y)
  2827. else if(count==5 || count==6)
  2828. dir=3; // all go to (x-1,y) and (x,y-1)
  2829. newStack[i].SetDir(dir);
  2830. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2831. turn=0;
  2832. }
  2833. // //if((++countnum)==n) return;
  2834. }
  2835. }
  2836. break;
  2837. }
  2838. case 7:
  2839. case 11:
  2840. case 13:
  2841. case 14:
  2842. {
  2843. // 7: all go to (x-1,y) and (x+1,y) and (x,y-1)
  2844. // 11:  all go to (x-1,y) and (x+1,y) and (x,y+1)
  2845. // 13: all go to (x-1,y) and (x,y-1) and (x,y+1)
  2846. // 14: all go to (x+1,y) and (x,y-1) and (x,y+1)
  2847. turn=0;
  2848. for(i=0;i<n;i++)
  2849. {
  2850. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2851. {
  2852. switch(turn)
  2853. {
  2854. case 0:
  2855. if(count==7 || count ==11 || count==13)
  2856. dir=0;
  2857. else
  2858. dir=2;
  2859. newStack[i].SetDir(dir);
  2860. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2861. turn=1;
  2862. break;
  2863. case 1:
  2864. if(count==7 || count==11)
  2865. dir=2;
  2866. else 
  2867. dir=3;
  2868. newStack[i].SetDir(dir);
  2869. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2870. turn=2;
  2871. break;
  2872. case 2:
  2873. if(count==7)
  2874. dir=3;
  2875. else
  2876. dir=1;
  2877. newStack[i].SetDir(dir);
  2878. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2879. turn=0;
  2880. break;
  2881. }
  2882. }
  2883. }
  2884. break;
  2885. }
  2887. case 9: // all go to (x-1,y) and (x,y+1)
  2888. case 10: // all go to (x+1,y) and (x,y+1)
  2889. case 12: // all go to (x,y-1) and (x,y+1)
  2890. {
  2891. turn=0;
  2892. for(i=0;i<n;i++)
  2893. {
  2894. if(EqualElement(_stackarray[i].GetCurrentPosition(),position))
  2895. {
  2896. switch(turn)
  2897. {
  2898. case 0:
  2899. if(count==9)
  2900. dir=0;
  2901. else if(count==10)
  2902. dir=2;
  2903. else if(count==12)
  2904. dir=3;
  2905. newStack[i].SetDir(dir);
  2906. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2907. turn=1;
  2908. break;
  2909. case 1:
  2910. dir=1;
  2911. newStack[i].SetDir(dir);
  2912. newStack[i].SearchPathStepByStep(markall,mark,pos);
  2913. turn=0;
  2914. break;
  2915. }
  2916. }
  2917. }
  2918. break;
  2919. }
  2920. case 15:
  2921. {
  2922. cout<<"error in allocate"<<endl;
  2923. exit(0);
  2924. }
  2925. default:
  2926. break;
  2928. }
  2929. }
  2930. else
  2931. {
  2932. // count the max priority
  2934. count=Max(markall[x-1][y],markall[x+1][y],markall[x][y-1],markall[x][y+1]);
  2935. int tag=0;
  2936. if(type==HUMAN)
  2937. HumanSubAllocate(count,newStack,n,position,::markall,mark,pos,tag);
  2938. else
  2939. SubAllocate(count,newStack,n,position,::markall,mark,pos,tag);
  2940. }
  2942. }
  2943. }
  2945. for(i=0;i<n;i++)
  2946. _stackarray[i]=newStack[i];
  2948. }
  2951. #endif