久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

搜索
查看: 4599|回復: 2
打印 上一主題 下一主題
收起左側

電腦鼠代碼（可以參考，不建議使用）

[復制鏈接]
跳轉到指定樓層
樓主
ID:419622 發表于 2018-11-2 13:20 | 只看該作者 回帖獎勵 |倒序瀏覽 |閱讀模式
不建議使用，可以參考

單片機源程序如下:
  1. #include "Maze.h"

  3. /*********************************************************************************************************
  4.   全局變量定義
  5. *********************************************************************************************************/
  6. static uint8    GucXStart                           = 0;                /*  起點橫坐標                  */
  7. static uint8    GucYStart                           = 0;                /*  起點縱坐標                  */

  9. static uint8    GucXGoal0                           = XDST0;            /*  終點X坐標，有兩個值         */
  10. static uint8    GucXGoal1                           = XDST1;
  11. static uint8    GucYGoal0                           = YDST0;            /*  終點Y坐標，有兩個值         */
  12. static uint8    GucYGoal1                           = YDST1;

  14. static uint8    GucMouseTask                        = WAIT;             /*  狀態機，初始狀態為等待      */

  16. static uint8    GucMapStep[MAZETYPE][MAZETYPE]      = {0xff};           /*  保存各坐標的等高值          */

  18. static MAZECOOR GmcStack[MAZETYPE * MAZETYPE]       = {0};              /* 在mapStepEdit()中作堆棧使用 */
  19. static MAZECOOR GmcCrossway[MAZETYPE * MAZETYPE]    = {0};              /* Main()中暫存未走過支路坐標() */
  20. //用戶自定義變量

  22. /*********************************************************************************************************
  23. ** Function name:       Delay
  24. ** Descriptions:        延時函數
  25. ** input parameters:    uiD :延時參數，值越大，延時越久
  26. ** output parameters:   無
  27. ** Returned value:      無
  28. *********************************************************************************************************/
  29. void delay (uint32 uiD)
  30. {
  31.     for (; uiD; uiD--);
  32. }

  34. /*********************************************************************************************************
  35. ** Function name:       mapStepEdit
  36. ** Descriptions:        制作以目標點為起點的等高圖
  37. ** input parameters:    uiX:    目的地橫坐標
  38. **                      uiY:    目的地縱坐標
  39. ** output parameters:   GucMapStep[][]:  各坐標上的等高值
  40. ** Returned value:      無
  41. *********************************************************************************************************/
  42. void mapStepEdit (int8  cX, int8  cY)
  43. {
  44.     uint8 n         = 0;                                                /*  GmcStack[]下標              */
  45.     uint8 ucStep    = 1;                                                /*  等高值                      */
  46.     uint8 ucStat    = 0;                                                /*  統計可前進的方向數          */
  47.     uint8 i,j;
  48.    
  49.     GmcStack[n].cX  = cX;                                               /*  起點X值入棧                 */
  50.     GmcStack[n].cY  = cY;                                               /*  起點Y值入棧                 */
  51.     n++;
  52.     /*
  53.      *  初始化各坐標等高值
  54.      */
  55.     for (i = 0; i < MAZETYPE; i++) {
  56.         for (j = 0; j < MAZETYPE; j++) {
  57.             GucMapStep[i][j] = 0xff;
  58.         }
  59.     }
  60.     /*
  61.      *  制作等高圖，直到堆棧中所有數據處理完畢
  62.      */
  63.     while (n) {
  64.         GucMapStep[cX][cY] = ucStep++;                                  /*  填入等高值                  */

  66.         /*
  67.          *  對當前坐標格里可前進的方向統計
  68.          */
  69.         ucStat = 0;
  70.         if ((GucMapBlock[cX][cY] & 0x01) &&                             /*  前方有路                    */
  71.             (GucMapStep[cX][cY + 1] > (ucStep))) {                      /*  前方等高值大于計劃設定值    */
  72.             ucStat++;                                                   /*  可前進方向數加1             */
  73.         }
  74.         if ((GucMapBlock[cX][cY] & 0x02) &&                             /*  右方有路                    */
  75.             (GucMapStep[cX + 1][cY] > (ucStep))) {                      /*  右方等高值大于計劃設定值    */
  76.             ucStat++;                                                   /*  可前進方向數加1             */
  77.         }
  78.         if ((GucMapBlock[cX][cY] & 0x04) &&
  79.             (GucMapStep[cX][cY - 1] > (ucStep))) {
  80.             ucStat++;                                                   /*  可前進方向數加1             */
  81.         }
  82.         if ((GucMapBlock[cX][cY] & 0x08) &&
  83.             (GucMapStep[cX - 1][cY] > (ucStep))) {
  84.             ucStat++;                                                   /*  可前進方向數加1             */
  85.         }
  86.         /*
  87.          *  沒有可前進的方向，則跳轉到最近保存的分支點
  88.          *  否則任選一可前進方向前進
  89.          */
  90.         if (ucStat == 0) {
  91.             n--;
  92.             cX = GmcStack[n].cX;
  93.             cY = GmcStack[n].cY;
  94.             ucStep = GucMapStep[cX][cY];
  95.         } else {
  96.             if (ucStat > 1) {                                           /*  有多個可前進方向，保存坐標  */
  97.                 GmcStack[n].cX = cX;                                    /*  橫坐標X值入棧               */
  98.                 GmcStack[n].cY = cY;                                    /*  縱坐標Y值入棧               */
  99.                 n++;
  100.             }
  101.             /*
  102.              *  任意選擇一條可前進的方向前進
  103.              */
  104.             if ((GucMapBlock[cX][cY] & 0x01) &&                         /*  上方有路                    */
  105.                 (GucMapStep[cX][cY + 1] > (ucStep))) {                  /*  上方等高值大于計劃設定值    */
  106.                 cY++;                                                   /*  修改坐標                    */
  107.                 continue;
  108.             }
  109.             if ((GucMapBlock[cX][cY] & 0x02) &&                         /*  右方有路                    */
  110.                 (GucMapStep[cX + 1][cY] > (ucStep))) {                  /*  右方等高值大于計劃設定值    */
  111.                 cX++;                                                   /*  修改坐標                    */
  112.                 continue;
  113.             }
  114.             if ((GucMapBlock[cX][cY] & 0x04) &&                         /*  下方有路                    */
  115.                 (GucMapStep[cX][cY - 1] > (ucStep))) {                  /*  下方等高值大于計劃設定值    */
  116.                 cY--;                                                   /*  修改坐標                    */
  117.                 continue;
  118.             }
  119.             if ((GucMapBlock[cX][cY] & 0x08) &&                         /*  左方有路                    */
  120.                 (GucMapStep[cX - 1][cY] > (ucStep))) {                  /*  左方等高值大于計劃設定值    */
  121.                 cX--;                                                   /*  修改坐標                    */
  122.                 continue;
  123.             }
  124.         }
  125.     }
  126. }
  127. /*********************************************************************************************************
  128. ** Function name:       mouseSpurt
  129. ** Descriptions:        電腦鼠從起點以最短路徑跑向終點
  130. ** input parameters:    無
  131. ** output parameters:  無
  132. ** Returned value:      無
  133. *********************************************************************************************************/
  134. void mouseSpurt (void)
  135. {
  136.     uint8 ucTemp = 0xff;
  137.     int8    cXdst = 0,    cYdst = 0;
  138.     /*
  139.      *  對終點的四個坐標分別制作等高圖
  140.      *  取離起點最近的一個點作為目標點
  141.      */
  142.     if (GucMapBlock[GucXGoal0][GucYGoal0] & 0x0c) {                     /*  判斷該終點坐標是否有出口    */
  143.         mapStepEdit(GucXGoal0,GucYGoal0);                               /*  制作等高圖                  */
  144.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存離起點最近的坐標        */
  145.             cXdst  = GucXGoal0;
  146.             cYdst  = GucYGoal0;
  147.             ucTemp = GucMapStep[GucXStart][GucYStart];
  148.         }
  149.     }
  150.     if (GucMapBlock[GucXGoal0][GucYGoal1] & 0x09) {                     /*  判斷該終點坐標是否有出口    */
  151.         mapStepEdit(GucXGoal0,GucYGoal1);                               /*  制作等高圖                  */
  152.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存離起點最近的坐標        */
  153.             cXdst  = GucXGoal0;
  154.             cYdst  = GucYGoal1;
  155.             ucTemp = GucMapStep[GucXStart][GucYStart];
  156.         }
  157.     }
  158.     if (GucMapBlock[GucXGoal1][GucYGoal0] & 0x06) {                     /*  判斷該終點坐標是否有出口    */
  159.         mapStepEdit(GucXGoal1,GucYGoal0);                               /*  制作等高圖                  */
  160.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存離起點最近的坐標        */
  161.             cXdst  = GucXGoal1;
  162.             cYdst  = GucYGoal0;
  163.             ucTemp = GucMapStep[GucXStart][GucYStart];
  164.         }
  165.     }
  166.     if (GucMapBlock[GucXGoal1][GucYGoal1] & 0x03) {                     /*  判斷該終點坐標是否有出口    */
  167.         mapStepEdit(GucXGoal1,GucYGoal1);                               /*  制作等高圖                  */
  168.         if (ucTemp > GucMapStep[GucXStart][GucYStart]) {                /*  保存離起點最近的坐標        */
  169.             cXdst  = GucXGoal1;
  170.             cYdst  = GucYGoal1;
  171.             ucTemp = GucMapStep[GucXStart][GucYStart];
  172.         }
  173.     }
  174.     zlg7289Download(1, 0, 1, 1);
  175.     zlg7289Download(1, 1, 1, 1);
  176.     zlg7289Download(1, 2, 1, 2);
  177.     zlg7289Download(1, 3, 1, 3);   
  178.     zlg7289Download(1, 4, 1, 4);   

  180.     objectGoTo(cXdst,cYdst);                                            /*  運行到指定目標點            */
  181. }
  182. /*********************************************************************************************************
  183. ** Function name:       objectGoTo
  184. ** Descriptions:        使電腦鼠運動到指定坐標
  185. ** input parameters:    cXdst: 目的地的橫坐標
  186. **                      cYdst: 目的地的縱坐標
  187. ** output parameters:   無
  188. ** Returned value:      無
  189. *********************************************************************************************************/
  190. void objectGoTo (int8  x, int8  y)
  191. {
  192.     uint8 ucStep = 1;
  193.     int8  cNBlock = 0, cDirTemp;
  194.     int8 cX,cY;
  195.     cX = GmcMouse.cX;
  196.     cY = GmcMouse.cY;
  197.     mapStepEdit(x,y);                                           /*  制作等高圖                  */
  198.     /*
  199.      *  根據等高值向目標點運動，直到達到目的地
  200.      */
  201.     while ((cX != x) || (cY != y)) {
  202.         ucStep = GucMapStep[cX][cY];
  203.         /*
  204.          *  任選一個等高值比當前自身等高值小的方向前進
  205.          */
  206.         if ((GucMapBlock[cX][cY] & 0x01) &&                             /*  上方有路                    */
  207.             (GucMapStep[cX][cY + 1] < ucStep)) {                        /*  上方等高值較小              */
  208.             cDirTemp = UP;                                              /*  記錄方向                    */
  209.             if (cDirTemp == GucMouseDir) {                              /*  優先選擇不需要轉彎的方向    */
  210.                 cNBlock++;                                              /*  前進一個方格                */
  211.                 cY++;
  212.                 continue;                                               /*  跳過本次循環                */
  213.             }
  214.         }
  215.         if ((GucMapBlock[cX][cY] & 0x02) &&                             /*  右方有路                    */
  216.             (GucMapStep[cX + 1][cY] < ucStep)) {                        /*  右方等高值較小              */
  217.             cDirTemp = RIGHT;                                           /*  記錄方向                    */
  218.             if (cDirTemp == GucMouseDir) {                              /*  優先選擇不需要轉彎的方向    */
  219.                 cNBlock++;                                              /*  前進一個方格                */
  220.                 cX++;
  221.                 continue;                                               /*  跳過本次循環                */
  222.             }
  223.         }
  224.         if ((GucMapBlock[cX][cY] & 0x04) &&                             /*  下方有路                    */
  225.             (GucMapStep[cX][cY - 1] < ucStep)) {                        /*  下方等高值較小              */
  226.             cDirTemp = DOWN;                                            /*  記錄方向                    */
  227.             if (cDirTemp == GucMouseDir) {                              /*  優先選擇不需要轉彎的方向    */
  228.                 cNBlock++;                                              /*  前進一個方格                */
  229.                 cY--;
  230.                 continue;                                               /*  跳過本次循環                */
  231.             }
  232.         }
  233.         if ((GucMapBlock[cX][cY] & 0x08) &&                             /*  左方有路                    */
  234.             (GucMapStep[cX - 1][cY] < ucStep)) {                        /*  左方等高值較小              */
  235.             cDirTemp = LEFT;                                            /*  記錄方向                    */
  236.             if (cDirTemp == GucMouseDir) {                              /*  優先選擇不需要轉彎的方向    */
  237.                 cNBlock++;                                              /*  前進一個方格                */
  238.                 cX--;
  239.                 continue;                                               /*  跳過本次循環                */
  240.             }
  241.         }
  242.         cDirTemp = (cDirTemp + 4 - GucMouseDir)%4;                      /*  計算方向偏移量              */
  243.         
  244.         if (cNBlock) {
  245.             mouseGoahead(cNBlock);                                      /*  前進cNBlock步               */
  246.         }        
  247.         cNBlock = 0;                                                    /*  任務清零                    */
  248.         
  249.         /*
  250.          *  控制電腦鼠轉彎
  251.          */
  252.         switch (cDirTemp) {

  254.         case 1:
  255.             mouseTurnright();
  256.             break;

  258.         case 2:
  259.             mouseTurnback();
  260.             break;

  262.         case 3:
  263.             mouseTurnleft();
  264.             break;

  266.         default:
  267.             break;
  268.         }
  269.     }
  270.     /*
  271.      *  判斷任務是否完成，否則繼續前進
  272.      */
  273.     if (cNBlock) {
  274.         mouseGoahead(cNBlock);
  275.     }
  276. }
  277. /*********************************************************************************************************
  278. ** Function name:       mazeBlockDataGet
  279. ** Descriptions:        根據電腦鼠的相對方向，取出該方向上迷宮格的墻壁資料
  280. ** input parameters:    ucDir: 電腦鼠的相對方向
  281. ** output parameters:   無
  282. ** Returned value:      GucMapBlock[cX][cY] : 墻壁資料
  283. *********************************************************************************************************/
  284. uint8 mazeBlockDataGet (uint8  ucDirTemp)
  285. {
  286.     int8 cX = 0,cY = 0;
  287.    
  288.     /*
  289.      *  把電腦鼠的相對方向轉換為絕對方向
  290.      */
  291.     switch (ucDirTemp) {

  293.     case MOUSEFRONT:
  294.         ucDirTemp = GucMouseDir;
  295.         break;

  297.     case MOUSELEFT:
  298.         ucDirTemp = (GucMouseDir + 3) % 4;
  299.         break;

  301.     case MOUSERIGHT:
  302.         ucDirTemp = (GucMouseDir + 1) % 4;
  303.         break;

  305.     default:
  306.         break;
  307.     }
  308.    
  309.     /*
  310.      *  根據絕對方向計算該方向上相鄰格的坐標
  311.      */
  312.     switch (ucDirTemp) {

  314.     case 0:
  315.         cX = GmcMouse.cX;
  316.         cY = GmcMouse.cY + 1;
  317.         break;
  318.         
  319.     case 1:
  320.         cX = GmcMouse.cX + 1;
  321.         cY = GmcMouse.cY;
  322.         break;
  323.         
  324.     case 2:
  325.         cX = GmcMouse.cX;
  326.         cY = GmcMouse.cY - 1;
  327.         break;
  328.         
  329.     case 3:
  330.         cX = GmcMouse.cX - 1;
  331.         cY = GmcMouse.cY;
  332.         break;
  333.         
  334.     default:
  335.         break;
  336.     }
  337.    
  338.     return(GucMapBlock[cX][cY]);                                        /*  返回迷宮格上的資料          */
  339. }
  340. /*********************************************************************************************************
  341. ** Function name:       rightMethod
  342. ** Descriptions:        右手法則，優先向右前進
  343. ** input parameters:    無
  344. ** output parameters:   無
  345. ** Returned value:      無
  346. *********************************************************************************************************/
  347. void rightMethod (void)
  348. {
  349.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  電腦鼠的右邊有路            */
  350.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  電腦鼠的右邊沒有走過        */
  351.         //delay(20000);
  352.        // delay(10000);
  353.         mouseTurnright();                                               /*  電腦鼠右轉                  */
  354.         return;
  355.     }
  356.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  電腦鼠的前方有路            */
  357.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  電腦鼠的前方沒有走過        */
  358.         return;                                                         /*  電腦鼠不用轉彎              */
  359.     }
  360.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  電腦鼠的左邊有路            */
  361.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  電腦鼠的左邊沒有走過        */
  362.        // delay(20000);
  363.        // delay(10000);
  364.         mouseTurnleft();                                                /*  電腦鼠左轉                  */
  365.         return;
  366.     }
  367. }
  368. /*********************************************************************************************************
  369. ** Function name:       leftMethod
  370. ** Descriptions:        左手法則，優先向左運動
  371. ** input parameters:    無
  372. ** output parameters:   無
  373. ** Returned value:      無
  374. *********************************************************************************************************/
  375. void leftMethod (void)
  376. {
  377.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  電腦鼠的左邊有路            */
  378.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  電腦鼠的左邊沒有走過        */
  379.         //delay(20000);
  380.        // delay(10000);
  381.         mouseTurnleft();                                                /*  電腦鼠左轉                  */
  382.         return;
  383.     }
  384.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  電腦鼠的前方有路            */
  385.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  電腦鼠的前方沒有走過        */
  386.         return;                                                         /*  電腦鼠不用轉彎              */
  387.     }
  388.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  電腦鼠的右邊有路            */
  389.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  電腦鼠的右邊沒有走過        */
  390.         //delay(20000);
  391.        // delay(10000);
  392.         mouseTurnright();                                               /*  電腦鼠右轉                  */
  393.         return;
  394.     }
  395. }
  396. /*********************************************************************************************************
  397. ** Function name:       frontRightMethod
  398. ** Descriptions:        中右法則，優先向前運行，其次向右
  399. ** input parameters:    無
  400. ** output parameters:   無
  401. ** Returned value:      無
  402. *********************************************************************************************************/
  403. void frontRightMethod (void)
  404. {
  405.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  電腦鼠的前方有路            */
  406.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  電腦鼠的前方沒有走過        */
  407.         return;                                                         /*  電腦鼠不用轉彎              */
  408.     }
  409.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  電腦鼠的右邊有路            */
  410.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  電腦鼠的右邊沒有走過        */
  411.         //delay(20000);
  412.         //delay(10000);
  413.         mouseTurnright();                                               /*  電腦鼠右轉                  */
  414.         return;
  415.     }
  416.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  電腦鼠的左邊有路            */
  417.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  電腦鼠的左邊沒有走過        */
  418.         //delay(20000);
  419.        // delay(10000);
  420.         mouseTurnleft();                                                /*  電腦鼠左轉                  */
  421.         return;
  422.     }
  423. }
  424. /*********************************************************************************************************
  425. ** Function name:       frontLeftMethod
  426. ** Descriptions:        中左法則，優先向前運行，其次向左
  427. ** input parameters:    無
  428. ** output parameters:   無
  429. ** Returned value:      無
  430. *********************************************************************************************************/
  431. void frontLeftMethod (void)
  432. {
  433.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  電腦鼠的前方有路            */
  434.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  電腦鼠的前方沒有走過        */
  435.         return;                                                         /*  電腦鼠不用轉彎              */
  436.     }
  437.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  電腦鼠的左邊有路            */
  438.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  電腦鼠的左邊沒有走過        */
  439.         //delay(20000);
  440.        // delay(10000);
  441.         mouseTurnleft();                                                /*  電腦鼠左轉                  */
  442.         return;
  443.     }
  444.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  電腦鼠的右邊有路            */
  445.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  電腦鼠的右邊沒有走過        */
  446.         //delay(20000);
  447.        // delay(10000);
  448.         mouseTurnright();                                               /*  電腦鼠右轉                  */
  449.         return;
  450.     }
  451. }
  452. /*********************************************************************************************************
  453. ** Function name:       centralMethod
  454. ** Descriptions:        中心法則，根據電腦鼠目前在迷宮中所處的位置覺定使用何種搜索法則
  455. ** input parameters:    無
  456. ** output parameters:   無
  457. ** Returned value:      無
  458. *********************************************************************************************************/
  459. void centralMethod (void)
  460. {
  461.     if (!(GmcMouse.cX & 0x08)) {
  462.         if (!(GmcMouse.cY & 0x08)) {
  463.          
  464.             /*
  465.              *  此時電腦鼠在迷宮的左下角
  466.              */   
  467.             switch (GucMouseDir) {
  468.                
  469.             case UP:                                                    /*  當前電腦鼠向上              */
  470.             //    delay(20000);  
  471.                 frontRightMethod();                                     /*  中右法則                    */
  472.                 break;

  474.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  475.             //    delay(20000);
  476.                 frontLeftMethod();                                      /*  中左法則                    */
  477.                 break;

  479.             case DOWN:                                                  /*  當前電腦鼠向下              */
  480.             //    delay(20000);
  481.                 leftMethod();                                           /*  左手法則                    */
  482.                 break;

  484.             case LEFT:                                                  /*  當前電腦鼠向左              */
  485.             //    delay(20000);
  486.                 rightMethod();                                          /*  右手法則                    */
  487.                 break;

  489.             default:
  490.                 break;
  491.             }

  493.         } else {
  494.          
  495.             /*
  496.              *  此時電腦鼠在迷宮的左上角
  497.              */   
  498.             switch (GucMouseDir) {
  499.                
  500.             case UP:                                                    /*  當前電腦鼠向上              */
  501.             //    delay(20000);
  502.                 rightMethod();                                          /*  右手法則                    */
  503.                 break;

  505.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  506.             //    delay(20000);
  507.                 frontRightMethod();                                     /*  中右法則                    */
  508.                 break;

  510.             case DOWN:                                                  /*  當前電腦鼠向下              */
  511.             //    delay(20000);
  512.                 frontLeftMethod();                                      /*  中左法則                    */
  513.                 break;

  515.             case LEFT:                                                  /*  當前電腦鼠向左              */
  516.             //    delay(20000);
  517.                 leftMethod();                                           /*  左手法則                    */
  518.                 break;

  520.             default:
  521.                 break;
  522.             }
  523.         }
  524.     } else {
  525.         if (!(GmcMouse.cY & 0x08)) {
  526.          
  527.             /*
  528.              *  此時電腦鼠在迷宮的右下角
  529.              */   
  530.             switch (GucMouseDir) {
  531.                
  532.             case UP:                                                    /*  當前電腦鼠向上              */
  533.             //    delay(20000);
  534.                 frontLeftMethod();                                      /*  中左法則                    */
  535.                 break;

  537.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  538.             //    delay(20000);
  539.                 leftMethod();                                           /*  左手法則                    */
  540.                 break;

  542.             case DOWN:                                                  /*  當前電腦鼠向下              */
  543.             //    delay(20000);
  544.                 rightMethod();                                          /*  右手法則                    */
  545.                 break;

  547.             case LEFT:                                                  /*  當前電腦鼠向左              */
  548.            //     delay(20000);
  549.                 frontRightMethod();                                     /*  中右法則                    */
  550.                 break;

  552.             default:
  553.                 break;
  554.             }
  555.             
  556.         } else {

  558.             /*
  559.              *  此時電腦鼠在迷宮的右上角
  560.              */
  561.             switch (GucMouseDir) {
  562.                
  563.             case UP:                                                    /*  當前電腦鼠向上              */
  564.            //     delay(20000);
  565.                 leftMethod();                                           /*  左手法則                    */
  566.                 break;

  568.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  569.            //     delay(20000);
  570.                 rightMethod();                                          /*  右手法則                    */
  571.                 break;

  573.             case DOWN:                                                  /*  當前電腦鼠向下              */
  574.            //     delay(20000);
  575.                 frontRightMethod();                                     /*  中右法則                    */
  576.                 break;

  578.             case LEFT:                                                  /*  當前電腦鼠向左              */
  579.             //    delay(20000);
  580.                 frontLeftMethod();                                      /*  中左法則                    */
  581.                 break;

  583.             default:
  584.                 break;
  585.             }            
  586.         }
  587.     }
  588. }

  590. //搜索返回的法則
  591. void mazeBackChoice()
  592. {
  593.     if (!(GmcMouse.cX & 0x08)) {
  594.         if (!(GmcMouse.cY & 0x08)) {
  595.          
  596.             /*
  597.              *  此時電腦鼠在迷宮的左下角
  598.              */   
  599.             switch (GucMouseDir) {
  600.                
  601.             case UP:                                                    /*  當前電腦鼠向上              */
  602.             //    delay(20000);  
  603.                 frontRightMethod();                                     /*  中右法則                    */
  604.                 break;

  606.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  607.             //    delay(20000);
  608.                 frontLeftMethod();                                      /*  中左法則                    */
  609.                 break;

  611.             case DOWN:                                                  /*  當前電腦鼠向下              */
  612.             //    delay(20000);
  613.                 leftMethod();                                           /*  左手法則                    */
  614.                 break;

  616.             case LEFT:                                                  /*  當前電腦鼠向左              */
  617.             //    delay(20000);
  618.                 rightMethod();                                          /*  右手法則                    */
  619.                 break;

  621.             default:
  622.                 break;
  623.             }

  625.         } else {
  626.          
  627.             /*
  628.              *  此時電腦鼠在迷宮的左上角
  629.              */   
  630.             switch (GucMouseDir) {
  631.                
  632.             case UP:                                                    /*  當前電腦鼠向上              */
  633.             //    delay(20000);
  634.                 rightMethod();                                          /*  右手法則                    */
  635.                 break;

  637.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  638.             //    delay(20000);
  639.                 frontRightMethod();                                     /*  中右法則                    */
  640.                 break;

  642.             case DOWN:                                                  /*  當前電腦鼠向下              */
  643.             //    delay(20000);
  644.                 frontLeftMethod();                                      /*  中左法則                    */
  645.                 break;

  647.             case LEFT:                                                  /*  當前電腦鼠向左              */
  648.             //    delay(20000);
  649.                 leftMethod();                                           /*  左手法則                    */
  650.                 break;

  652.             default:
  653.                 break;
  654.             }
  655.         }
  656.     } else {
  657.         if (!(GmcMouse.cY & 0x08)) {
  658.          
  659.             /*
  660.              *  此時電腦鼠在迷宮的右下角
  661.              */   
  662.             switch (GucMouseDir) {
  663.                
  664.             case UP:                                                    /*  當前電腦鼠向上              */
  665.             //    delay(20000);
  666.                 frontLeftMethod();                                      /*  中左法則                    */
  667.                 break;

  669.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  670.             //    delay(20000);
  671.                 leftMethod();                                           /*  左手法則                    */
  672.                 break;

  674.             case DOWN:                                                  /*  當前電腦鼠向下              */
  675.             //    delay(20000);
  676.                 rightMethod();                                          /*  右手法則                    */
  677.                 break;

  679.             case LEFT:                                                  /*  當前電腦鼠向左              */
  680.            //     delay(20000);
  681.                 frontRightMethod();                                     /*  中右法則                    */
  682.                 break;

  684.             default:
  685.                 break;
  686.             }
  687.             
  688.         } else {

  690.             /*
  691.              *  此時電腦鼠在迷宮的右上角
  692.              */
  693.             switch (GucMouseDir) {
  694.                
  695.             case UP:                                                    /*  當前電腦鼠向上              */
  696.            //     delay(20000);
  697.                 leftMethod();                                           /*  左手法則                    */
  698.                 break;

  700.             case RIGHT:                                                 /*  當前電腦鼠向右              */
  701.            //     delay(20000);
  702.                 rightMethod();                                          /*  右手法則                    */
  703.                 break;

  705.             case DOWN:                                                  /*  當前電腦鼠向下              */
  706.            //     delay(20000);
  707.                 frontRightMethod();                                     /*  中右法則                    */
  708.                 break;

  710.             case LEFT:                                                  /*  當前電腦鼠向左              */
  711.             //    delay(20000);
  712.                 frontLeftMethod();                                      /*  中左法則                    */
  713.                 break;

  715.             default:
  716.                 break;
  717.             }            
  718.         }
  719.     }
  720. }
  721. /*********************************************************************************************************
  722. ** Function name:       crosswayCheck
  723. ** Descriptions:        統計某坐標存在還未走過的支路數
  724. ** input parameters:    ucX，需要檢測點的橫坐標
  725. **                      ucY，需要檢測點的縱坐標
  726. ** output parameters:   無
  727. ** Returned value:      ucCt，未走過的支路數
  728. *********************************************************************************************************/
  729. uint8 crosswayCheck (int8  cX, int8  cY)
  730. {
  731.     uint8 ucCt = 0;
  732.     if ((GucMapBlock[cX][cY] & 0x01) &&                                 /*  絕對方向，迷宮上方有路      */
  733.         (GucMapBlock[cX][cY + 1]) == 0x00) {                            /*  絕對方向，迷宮上方未走過    */
  734.         ucCt++;                                                         /*  可前進方向數加1             */
  735.     }
  736.     if ((GucMapBlock[cX][cY] & 0x02) &&                                 /*  絕對方向，迷宮右方有路      */
  737.         (GucMapBlock[cX + 1][cY]) == 0x00) {                            /*  絕對方向，迷宮右方沒有走過  */
  738.         ucCt++;                                                         /*  可前進方向數加1             */
  739.     }
  740.     if ((GucMapBlock[cX][cY] & 0x04) &&                                 /*  絕對方向，迷宮下方有路      */
  741.         (GucMapBlock[cX][cY - 1]) == 0x00) {                            /*  絕對方向，迷宮下方未走過    */
  742.         ucCt++;                                                         /*  可前進方向數加1             */
  743.     }
  744.     if ((GucMapBlock[cX][cY] & 0x08) &&                                 /*  絕對方向，迷宮左方有路      */
  745.         (GucMapBlock[cX - 1][cY]) == 0x00) {                            /*  絕對方向，迷宮左方未走過    */
  746.         ucCt++;                                                         /*  可前進方向數加1             */
  747.     }
  748.     return ucCt;
  749. }
  750. /*********************************************************************************************************
  751. ** Function name:       crosswayChoice
  752. ** Descriptions:        選擇一條支路作為前進方向
  753. ** input parameters:    無
  754. ** output parameters:   無
  755. ** Returned value:      無
  756. *********************************************************************************************************/
  757. void crosswayChoice (void)
  758. {
  759.     switch (SEARCHMETHOD) {
  760.         
  761.     case RIGHTMETHOD:
  762.         rightMethod();
  763.         break;
  764.    
  765.     case LEFTMETHOD:
  766.         leftMethod();
  767.         break;
  768.    
  769.     case CENTRALMETHOD:
  770.         centralMethod();
  771.         break;

  773.     case FRONTRIGHTMETHOD:
  774.         frontRightMethod();
  775.         break;

  777.     case FRONTLEFTMETHOD:
  778.         frontLeftMethod();
  779.         break;

  781.     default:
  782.         break;
  783.     }
  784. }
  785. /*********************************************************************************************************
  786. ** Function name:      StopMazeSearch
  787. ** Descriptions:      停止向前搜索的函數   
  788. ** input parameters:    當前的坐標
  789. ** output parameters:     無
  790. ** Returned value:      0代表結束，1代表繼續
  791. *********************************************************************************************************/
  792. int8 StopMazeSearch(int8 cX,int8 cY)
  793. {
  794.     if(cX==7 && cY==7)
  795.         return 1;
  796.     if(cX==8 && cY==7)
  797.         return 1;
  798.     if(cX==7 && cY==8)
  799.         return 1;
  800.     if(cX==8 && cY==8)
  801.         return 1;
  802.     return 0;
  803. }
  804. /*********************************************************************************************************
  805. ** Function name:      FastOperating
  806. ** Descriptions:     對特殊格子處理的函數  
  807. ** input parameters:    當前的坐標
  808. ** output parameters:     無
  809. ** Returned value:      1表示前方，2表示右方，3表示后方，4表示左方
  810. *********************************************************************************************************/
  811. int8 FastOperating(int8 cX,int8 cY)
  812. {
  813.   if(cX==5 && cY==7){
  814.       if(GucMapBlock[cX][cY] & 0x02)
  815.         return 2;
  816.   }
  817.   if(cX==5 && cY==8){
  818.       if(GucMapBlock[cX][cY] & 0x02)
  819.         return 2;
  820.   }
  821.   
  822.   if(cX==6 && cY==7){
  823.       if(GucMapBlock[cX][cY] & 0x02)
  824.         return 2;
  825.   }
  826.   if(cX==6 && cY==8){
  827.       if(GucMapBlock[cX][cY] & 0x02)
  828.         return 2;
  829.   }
  830.   
  831.   if(cX==7 && cY==5){
  832.       if(GucMapBlock[cX][cY] & 0x01)
  833.         return 1;
  834.   }
  835.   if(cX==8 && cY==5){
  836.       if(GucMapBlock[cX][cY] & 0x01)
  837.         return 1;
  838.   }
  839.   if(cX==7 && cY==6){
  840.       if(GucMapBlock[cX][cY] & 0x01)
  841.         return 1;
  842.   }
  843.   if(cX==8 && cY==6){
  844.       if(GucMapBlock[cX][cY] & 0x01)
  845.         return 1;
  846.   }
  847.   
  848.   if(cX==10 && cY==7){
  849.       if(GucMapBlock[cX][cY] & 0x08)
  850.         return 4;
  851.   }
  852.   if(cX==10 && cY==8){
  853.       if(GucMapBlock[cX][cY] & 0x08)
  854.         return 4;
  855.   }
  856.   if(cX==9 && cY==7){
  857.       if(GucMapBlock[cX][cY] & 0x08)
  858.         return 4;
  859.   }
  860.   if(cX==9 && cY==8){
  861.       if(GucMapBlock[cX][cY] & 0x08)
  862.         return 4;
  863.   }
  864.   
  865.   if(cX==8 && cY==10){
  866.       if(GucMapBlock[cX][cY] & 0x04)
  867.         return 3;
  868.   }
  869.   if(cX==7 && cY==10){
  870.       if(GucMapBlock[cX][cY] & 0x04)
  871.         return 3;
  872.   }
  873.   if(cX==8 && cY==9){
  874.       if(GucMapBlock[cX][cY] & 0x04)
  875.         return 3;
  876.   }
  877.   if(cX==7 && cY==9){
  878.       if(GucMapBlock[cX][cY] & 0x04)
  879.         return 3;
  880.   }
  881.   return 0;
  882. }
  883. /*********************************************************************************************************
  884. ** Function name:       piontMethod
  885. ** Descriptions:        向點法則，電腦鼠從終點找起點
  886. ** input parameters:    無
  887. ** output parameters:   無
  888. ** Returned value:      無
  889. *********************************************************************************************************/
  890. void piontMethod(void)
  891. {
  892.     switch(GucMouseDir)
  893.     {
  894.     case UP:
  895.       leftMethod();
  896.       break;
  897.     case RIGHT:
  898.       rightMethod();
  899.       break;
  900.     case DOWN:
  901.       frontRightMethod();
  902.       break;
  903.     case LEFT:
  904.       frontLeftMethod();
  905.       break;
  906.     default:
  907.       break;
  908.     }
  909. }
  910. /*********************************************************************************************************
  911. ** Function name:      StopMazeSearch
  912. ** Descriptions:      停止向前搜索的函數   
  913. ** input parameters:    當前的坐標
  914. ** output parameters:     無
  915. ** Returned value:      0代表結束，1代表繼續
  916. *********************************************************************************************************/
  917. int8 StopSearch(int8 cX,int8 cY,int8 n)
  918. {
  919.    int8 i;
  920.    for(i=0;i<n;i++){
  921.       if(GmcCrossway[i].cX == cX && GmcCrossway[i].cY == cY){
  922.           return 1;
  923.       }
  924.    }
  925.    if(cX==7 && cY==7)
  926.        return 1;
  927.    if(cX==8 && cY==7)
  928.        return 1;
  929.    if(cX==7 && cY==8)
  930.        return 1;
  931.    if(cX==8 && cY==8)
  932.        return 1;
  933.     return 0;
  934. }
  935. /*********************************************************************************************************
  936. ** Function name:       main
  937. ** Descriptions:      主函數
  938. ** input parameters:    無
  939. ** output parameters:   無
  940. ** Returned value:      無
  941. *********************************************************************************************************/
  942. main (void)
  943. {
  944.     uint8 n          = 0;                                               /*  GmcCrossway[]下標           */  
  945.     uint8 ucRoadStat = 0;                                               /*  統計某一坐標可前進的支路數  */
  946.     uint8 ucTemp     = 0;                                               /*  用于START狀態中坐標轉換     */
  947.    
  948.     //用戶自定義變量
  949.     int8    cXdst = 0,    cYdst = 0;
  950.    
  951.     mouseInit();                                                        /*  底層驅動的初始化            */
  952.     zlg7289Init();                                                      /*  顯示模塊初始化              */

  954.     while (1) {
  955.         switch (GucMouseTask) {                                         /*  狀態機處理                  */
  956.             
  957.         case WAIT:
  958.             sensorDebug();
  959.             voltageDetect();
  960.             delay(100000);
  961.             if (keyCheck() == true) {                                   /*  檢測按鍵等待啟動            */
  962.                 zlg7289Reset();                                         /*  復位ZLG7289                 */
  963.                 GucMouseTask = START;
  964.             }
  965.             break;
  966.             
  967.         case START:                                                     /*  判斷電腦鼠起點的橫坐標      */
  968.             mazeSearch();                                               /*  向前搜索                    */
  969.             if (GucMapBlock[GmcMouse.cX][GmcMouse.cY] & 0x08) {         /*  判斷電老鼠左邊是否存在出口  */
  970.                 if (MAZETYPE == 8) {                                    /*  修改四分之一迷宮的終點坐標  */
  971.                     GucXGoal0 = 1;
  972.                     GucXGoal1 = 0;
  973.                 }
  974.                 GucXStart   = MAZETYPE - 1;                             /*  修改電腦鼠起點的橫坐標      */
  975.                 GmcMouse.cX = MAZETYPE - 1;                             /*  修改電腦鼠當前位置的橫坐標  */   
  976.                 /*
  977.                  *  由于默認的起點為(0,0)，現在需要把已記錄的墻壁資料轉換過來
  978.                  */
  979.                 ucTemp = GmcMouse.cY;
  980.                 do {
  981.                     GucMapBlock[MAZETYPE - 1][ucTemp] = GucMapBlock[0][ucTemp];
  982.                     GucMapBlock[0 ][ucTemp] = 0;
  983.                 }while (ucTemp--);
  984.                 /*
  985.                  *  在OFFSHOOT[0]中保存起點坐標
  986.                  */
  987.                 GmcCrossway[n].cX = MAZETYPE - 1;
  988.                 GmcCrossway[n].cY = 0;
  989.                 n++;
  990.                 GucMouseTask = MAZESEARCH;                              /*  狀態轉換為搜尋狀態          */
  991.             }
  992.             if (GucMapBlock[GmcMouse.cX][GmcMouse.cY] & 0x02) {         /*  判斷電老鼠右邊是否存在出口  */
  993.                 /*
  994.                  *  在OFFSHOOT[0]中保存起點坐標
  995.                  */
  996.                 GmcCrossway[n].cX = 0;
  997.                 GmcCrossway[n].cY = 0;
  998.                 n++;
  999.                 GucMouseTask = MAZESEARCH;                              /*  狀態轉換為搜尋狀態          */
  1000.             }
  1001.             break;
  1002.             
  1003.         case MAZESEARCH:
  1004.               //從起點搜索找終點
  1005.               if(StopMazeSearch(GmcMouse.cX,GmcMouse.cY)==1){
  1006.                     cXdst=GmcMouse.cX,cYdst=GmcMouse.cY;
  1007.                     mouseTurnback();
  1008.                     GucMouseTask = BACKSEARCH;
  1009.                     n--;
  1010.                     objectGoTo(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1011.                     break;
  1012.                }
  1013.                ucRoadStat = crosswayCheck(GmcMouse.cX,GmcMouse.cY);
  1014.                if (ucRoadStat) {                                           /*  有可前進方向                */                  
  1015.                     if (ucRoadStat > 1) {                                   /*  有多條可前進方向，保存坐標  */
  1016.                         GmcCrossway[n].cX = GmcMouse.cX;
  1017.                         GmcCrossway[n].cY = GmcMouse.cY;
  1018.                         n++;                                       
  1019.                     }
  1020.                     switch(FastOperating(GmcMouse.cX,GmcMouse.cY)){
  1021.                         case 0:
  1022.                             centralMethod();
  1023.                             mazeSearch();
  1024.                             break;
  1025.                         case 1:
  1026.                            objectGoTo(GmcMouse.cX,GmcMouse.cY+1);
  1027.                            //  mazeSearch();
  1028.                             break;
  1029.                         case 2:
  1030.                           objectGoTo(GmcMouse.cX+1,GmcMouse.cY);
  1031.                           //    mazeSearch();
  1032.                             break;
  1033.                         case 3:
  1034.                            objectGoTo(GmcMouse.cX,GmcMouse.cY-1);
  1035.                           //   mazeSearch();
  1036.                             break;
  1037.                         case 4:
  1038.                            objectGoTo(GmcMouse.cX-1,GmcMouse.cY);
  1039.                            //  mazeSearch();
  1040.                             break;
  1041.                        default:
  1042.                             break;
  1043.                     }
  1044.                }else{                    /*  沒有可前進方向，回到最近支路*/
  1045.                     while (--n) {
  1046.                           ucRoadStat = crosswayCheck(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1047.                           if (ucRoadStat) {
  1048.                               objectGoTo(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1049.                               if (ucRoadStat > 1) {
  1050.                                   n++;
  1051.                               }
  1052.                               centralMethod();
  1053.                               mazeSearch();
  1054.                               break;
  1055.                           }
  1056.                     
  1057.                      }
  1058.                    if (n == 0){                                           /*  走完了所有的支路，回到起點  */
  1059.                         objectGoTo(GmcCrossway[0].cX, GmcCrossway[0].cY);
  1060.                         mouseTurnback();
  1061.                            //異常處理那種死迷宮(即根本走不出去的迷宮)
  1062.                         if(GmcMouse.cX==GucXStart && GmcMouse.cY==GucYStart){
  1063.                             while(1){
  1064.                                 if(keyCheck()==true){
  1065.                                     break;
  1066.                                 }
  1067.                                 sensorDebug();
  1068.                                 delay(20000);
  1069.                             }
  1070.                         }
  1071.                     }
  1072.                 }
  1073.                 break;
  1074.          case BACKSEARCH:
  1075.              //從終點搜索找起點
  1076.              /*  while(1){
  1077.                     if(keyCheck()==true){
  1078.                          break;
  1079.                     }
  1080.                     sensorDebug();
  1081.                     delay(20000);
  1082.                 }*/
  1083.                 ucRoadStat = crosswayCheck(GmcMouse.cX,GmcMouse.cY);               
  1084.                 if (ucRoadStat) {                                           /*  有可前進方向                */
  1085.                     if (ucRoadStat > 1) {                                   /*  有多條可前進方向，保存坐標  */
  1086.                         GmcCrossway[n].cX = GmcMouse.cX;
  1087.                         GmcCrossway[n].cY = GmcMouse.cY;
  1088.                         n++;                                       
  1089.                     }
  1090.                     piontMethod();       //設定為向點法則                                
  1091.                     mazeSearch();          // 前進一格               
  1092.                     }else{                    /*  沒有可前進方向，回到最近支路*/
  1093.                         while (--n) {
  1094.                             if(GmcMouse.cX==0 && GmcMouse.cY==0){
  1095.                                 mouseTurnback();
  1096.                                 GucMouseTask=SPURT;
  1097.                                 break;
  1098.                             }
  1099.                             ucRoadStat = crosswayCheck(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1100.                             if(ucRoadStat) {
  1101.                                 objectGoTo(GmcCrossway[n].cX,GmcCrossway[n].cY);
  1102.                                 if (ucRoadStat > 1) {
  1103.                                     n++;
  1104.                                 }
  1105.                                 piontMethod();
  1106.                                 mazeSearch();
  1107.                                 break;
  1108.                            }
  1109.                            if(n==0){
  1110.                              GucMouseTask=SPURT;
  1111.                              break;
  1112.                         }
  1113.                     }
  1114.                 }
  1115.                 break;
  1116.         case SPURT:
  1117.           //  mouseSpurt ();
  1118.             objectGoTo(cXdst,cYdst);
  1119.             n--;
  1120.             objectGoTo(GmcCrossway[n].cX, GmcCrossway[n].cY);
  1121.             GucMouseTask = BACKSEARCH;
  1122.             break;
  1123.         default:
  1124.             break;
  1125.         }
  1126.     }
  1127. }


  1130. /*********************************************************************************************************
  1131.   END FILE
  1132. *********************************************************************************************************/





  1138. /*********************************************************************************************************
  1139. ** Function name:       piontMethod
  1140. ** Descriptions:        向點法則，電腦鼠從終點找起點
  1141. ** input parameters:    無
  1142. ** output parameters:   GmcMouse.cX,GmcMouse.cY
  1143. ** Returned value:      無
  1144. *********************************************************************************************************/

  1146. void piontMethod(int8 cX,int8 cY)
  1147. {
  1148.         if (!(GmcMouse.cX & 0x08))
  1149.         {
  1150.         if (!(GmcMouse.cY & 0x08))
  1151.                 {
  1152.                                 /*
  1153.                                  *  此時電腦鼠在迷宮的左下角
  1154.                                  */  
  1155.                                 switch (GucMouseDir)
  1156.                                 {
  1157.                         
  1158.                                 case UP:                                                    /*  當前電腦鼠向上              */
  1159.                                         LeftMethod();                                                                                        /*  左手法則                    */
  1160.                                         break;

  1162.                                 case RIGHT:                                                 /*  當前電腦鼠向右              */
  1163.                                         RightMethod();                                          /*  右手法則                    */
  1164.                                         break;

  1166.                                 case DOWN:                                                  /*  當前電腦鼠向下              */
  1167.                                         frontRightMethod();                                     /*  中右手法則                    */
  1168.                                         break;

  1170.                                 case LEFT:                                                  /*  當前電腦鼠向左              */
  1171.                                         frontLeftMethod();                                      /*  中左手法則                    */
  1172.                                         break;

  1174.                                 default:
  1175.                                         break;
  1176.                         ｝
  1177.                 }
  1178.     }
  1179.         else
  1180.         {
  1181.         
  1182.             frontLeftMethod();                                      /*  中左法則                    */


  1185.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_F) &&         /*  電腦鼠的前方有路            */
  1186.         (mazeBlockDataGet(MOUSEFRONT) == 0x00)) {                       /*  電腦鼠的前方沒有走過        */
  1187.         return;                                                         /*  電腦鼠不用轉彎              */
  1188.     }
  1189.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_L) &&         /*  電腦鼠的左邊有路            */
  1190.         (mazeBlockDataGet(MOUSELEFT ) == 0x00)) {                       /*  電腦鼠的左邊沒有走過        */
  1191.         //delay(20000);
  1192.        // delay(10000);
  1193.         mouseTurnleft();                                                /*  電腦鼠左轉                  */
  1194.         return;
  1195.     }
  1196.     if ((GucMapBlock[GmcMouse.cX][GmcMouse.cY] & MOUSEWAY_R) &&         /*  電腦鼠的右邊有路            */
  1197.         (mazeBlockDataGet(MOUSERIGHT) == 0x00)) {                       /*  電腦鼠的右邊沒有走過        */
  1198.         //delay(20000);
  1199.        // delay(10000);
  1200.         mouseTurnright();                                               /*  電腦鼠右轉                  */
  1201.         return;
  1202.     }
  1203.     }
  1204. }
復制代碼

所有資料51hei提供下載:
.rar (198.73 KB, 下載次數: 18)



分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏2 分享淘帖 頂頂 踩踩
回復

使用道具 舉報

沙發
ID:687193 發表于 2020-1-18 17:24 | 只看該作者
有這個代碼的頭文件嗎
回復

使用道具 舉報

板凳
ID:687193 發表于 2020-1-18 17:25 | 只看該作者
有這個代碼的頭文件嗎
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板： 国产精品成人久久久久a级 久久蜜桃av一区二区天堂 | 亚洲精品成人在线 | 亚洲综合成人网 | 成人精品一区二区三区中文字幕 | 91久久久精品国产一区二区蜜臀 | 国产精品免费观看 | 日韩免费毛片 | 久久国产精品免费 | 欧美另类视频在线 | 成人一区二区三区视频 | 中文字幕一区二区三区不卡 | 99视频在线免费观看 | 欧美在线视频一区二区 | 亚洲一区二区三区四区五区午夜 | 国产精品国产精品国产专区不卡 | 国产精品一区久久久 | 国产免费视频 | 亚洲精品视频免费观看 | 爱综合 | 欧美美女被c | 一呦二呦三呦国产精品 | 久久久久精| 精品综合久久久 | 精品国产乱码久久久久久丨区2区 | 2022精品国偷自产免费观看 | 欧美在线视频一区二区 | 日韩在线不卡 | 精品一区二区三区在线视频 | 99久久99| 亚洲手机视频在线 | 精品视频一区二区三区 | 久久久久国产 | 欧美福利精品 | 精品国产欧美一区二区三区成人 | 久久com| 日韩精品视频在线观看一区二区三区 | 在线观看www | 亚洲啊v在线 | 国产一区二区三区网站 | 亚洲精品久久久久久久久久久久久 | 国产一级片在线观看视频 |