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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > J2ME > 查看源码
GameWorld.java
资源名称：PaoPao.rar　[点击查看]
上传用户：sh2222
上传日期：2009-12-31
资源大小：84k
文件大小：32k
源码类别：

J2ME

开发平台：

Java

GameWorld.java：源码内容
  1. package paopao;
  3. import javax.microedition.lcdui.*;
  4. import java.util.Hashtable;
  5. import java.io.InputStream;
  6. import com.nokia.mid.ui.*;
  8. public class GameWorld extends FullCanvas implements Runnable{
  9. final int screenW = getWidth();
  10. final int screenH = getHeight();
  11. final int paintW = 128;
  12. final int paintH = 208 - 3;
  13. final int orgX = 7;
  14. final int orgY = 3;
  15. final int midX = paintW / 2;
  16. final int midY = paintH / 2;
  17. //score
  18. int score;
  19. //Thread
  20. boolean killThread  = false;
  21. boolean pauseThread = false;
  22. boolean overThread  = false;
  23. int overCount;
  24. Thread thread = null;
  25. int interval = 50;
  26. //hardlevel setting
  27. int hardLevel;
  28. final int EASY   = 9;
  29. final int MIDDLE = 8;
  30. final int HARD   = 6;
  31. int shakeAt;                    //when ball shooted number equals or more then it shakes
  32. boolean shaking = false;
  33. int shakeOffX[];
  34. // top press
  35. int pressCount;                //round intervals per top down count
  36. int shakeCount;
  37. int nowTop;
  38. //angle
  39. int angle  = 90;
  40. int _angle = 6;
  41. int angleSinValue;
  42. int angleCosValue;
  43. //paopao
  44. int nextOneColor;
  45. int toBeShootColor;
  46. int isMovingColor;
  47. boolean isMoving = false;    //击出的球是否处于运动过程中
  48. int shootAngle;
  49. int v = 10;
  50. int timeCount;
  51. final int effectiveR = 8;
  52. final int localStand = 6;
  53. int startX;
  54. int startY;
  55. int nowX;
  56. int nowY;
  57. boolean hitted = false;
  58. int hittedI;
  59. int hittedJ;
  60. //falling
  61. int fallingNum ;
  62. int[][] fallingPara;
  63. int fallingV = 8;
  64. //time
  66. //round
  67. int[][] roundPara;
  68. int roundCount;                  //read roundPara from map.txt & count
  69. boolean roundStart = true;
  70. int roundStartCount;
  71. int round = 1;
  73. //
  74. int disappearCount;
  75.   /** Constructor */
  76.   public GameWorld(int hardLevel) {
  77.     this.hardLevel = hardLevel;
  78.     try {
  79.       jbInit();
  80.     }
  81.     catch(Exception e) {
  82.       e.printStackTrace();
  83.     }
  84.   }
  86.   protected void show()
  87.   {
  88.   if(thread == null)
  89.     thread = new Thread(this);
  90.     thread.start();
  91.   }
  92.   /**Component initialization*/
  93.   private void jbInit() throws Exception {
  94.   roundPara = new int[11][8];
  95.   this.readroundPara();
  96.   switch(hardLevel)
  97.   {
  98.   case EASY:
  99.   shakeAt = 6;
  100.   break;
  101.   case MIDDLE:
  102.   shakeAt = 5;
  103.   break;
  104.   case HARD:
  105.   shakeAt = 4;
  106.   break;
  107.   default:
  108.   break;
  109.   }
  110.   toBeShootColor =  1 + Math.abs(Resource.random.nextInt() % 8);
  111.   nextOneColor   = 1 + Math.abs(Resource.random.nextInt() % 8);
  112.   fallingPara = new int[50][3];
  113.   shakeOffX = new int[]{1,1,1,1,-1,-1,-1,-1,-1,-1,-1,-1,1,1,1,1};
  114. // Set up this Displayable to listen to command events
  115.     // add the Exit command
  116.   }
  117.   private  void readroundPara()
  118.     {
  119.       InputStream is = null;
  120.      try{
  121.         is = getClass().getResourceAsStream("/round.txt");
  122.         }
  123.       catch(Exception e)
  124.         {}
  125.       int symbol;
  126.       try{
  127.   while((symbol = is.read()) != -1)
  128.    {
  129.           if(symbol == '&')
  130.               {
  131.             roundCount ++;
  132.             if(roundCount == round)
  133.                    {
  134.                for(int i = 0;i < 5;i ++)
  135.                is.read();
  136.                int symbol2;
  137.                int rowCount  = 0;
  138.                int lineCount = 0;
  139.                while((symbol2 = is.read()) != '&')
  140.                       {
  141.                    if(symbol2 == 'r')
  142.                            {
  143.                      rowCount ++;
  144.                      lineCount = 0;
  145.                      is.read();
  146.                            }
  147.                     else roundPara[rowCount][lineCount ++] = (int)symbol2 - 48;
  148.                       }
  149.                   break;
  150.                    }
  151.                 }
  152.    }
  154.          }
  155.       catch(Exception ex)
  156.       {
  157.       }
  159.     }
  160. private void nextPaoPao()
  161.   {
  162.   isMovingColor = toBeShootColor;
  163.   toBeShootColor = nextOneColor;
  164.   nextOneColor = 1 + Math.abs(Resource.random.nextInt() % 8);
  165.   }
  166. protected void keyPressed(int keyCode)
  167.   {
  168. if(!pauseThread)
  169.     {
  170. if(keyCode == -6)
  171. PaoPao.quitApp();
  172. else if((keyCode == -5 || keyCode == 53) && isMoving  == false)
  173.   shoot();
  174. else if(keyCode == -3)
  175.     {
  176.       if(angle < 174)
  177.       angle += 6;
  178.     }
  179. else if(keyCode == -4)
  180.     {
  181.       if(angle > 6)
  182.       angle -= 6;
  183.     }
  184. else if(keyCode == -1)
  185.            {
  186.            if(angle == 90)
  187.              return;
  188.            angle = (angle > 90 ? angle - 6 : angle + 6);
  189.            }
  191.     }      //if(!pauseThread)
  192.   }
  193.   /**Handle command events*/
  194. synchronized private void shoot()
  195.   {
  196. //pressCount ++;
  197. //pressCount %= hardLevel;
  198. //if(pressCount >= shakeAt)
  199. //shaking = true;
  200. //if(pressCount == 0)
  201. //topDown();
  202. startX = 71 - orgX;
  203. startY = 170 - orgY;
  204. nowX = startX;
  205. nowY = startY;
  206. shootAngle = angle;
  207. angleSinValue = Resource.getSinAngleValue(shootAngle);
  208. angleCosValue = Resource.getCosAngleValue(shootAngle);
  209. isMoving = true;
  210. timeCount = 0;
  211. nextPaoPao();
  212.   }
  213. private void topDown()
  214.   {
  215. nowTop ++;
  216. shaking = false;
  217.   }
  218.  public void run()
  219.  {
  220.  while(!killThread)
  221.      {
  222.      if(!pauseThread)
  223.         {
  224.       if(!overThread)
  225.             {
  226.      if(roundStart)
  227.               {
  228.                  roundStartCount ++;
  229.                 if(roundStartCount >= 48)
  230.                  {
  231.                 roundStartCount = 0;
  232.                 roundStart = false;
  233.                  }
  234.               }
  235.               if(isMoving)    //被击出的球处于运动状态中
  236.                 {
  237.                   paoPaoMoving();
  238.                 }
  239.                Falling();
  240.                if(disappearCount > 0)
  241.                {
  242.                  disappearCount --;
  243.                  if(disappearCount == 0)
  244.                    for(int i = 0;i < 10;i ++)
  245.                      for(int j = 0;j < (i % 2 == 0 ? 8 : 7);j ++)
  246.                      {
  247.                      if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
  248.                        roundPara[i][j] = 0;
  249.                      }
  250.                }
  251.                if(shaking)
  252.                {
  253.               shakeCount ++;
  254.               shakeCount %= 16;
  255.                }
  256.                 try
  257.                 {
  258.                 repaint();
  259.                 thread.sleep(interval);
  260.                 }
  261.                 catch(Exception ex){}
  262.             }          //if(!overThread)
  263.       //overCount ++;
  264.      // if(overCount >= paintH - nowTop * 14)
  265.       //  killThread = true;
  266.         }
  267.      }               //while(!killThread)
  268. //System.out.println("killThread = "+ killThread);
  269.          this.serviceRepaints();
  270.          System.gc();
  271.          PaoPao.shiftCanvas(PaoPao.MENU_ID,0);
  273.  }
  274. private void Falling()
  275.  {
  276.  if(fallingNum > 0)
  277.   {
  278.  for(int i = 0;i < fallingNum;i ++)
  279.     {
  280.     fallingPara[i][2] += fallingV;
  281.     }
  282.   }
  284. for(int i = 0;i < fallingNum;i ++)
  285.   {
  286.  if(fallingPara[i][2] > paintH + 8)
  287.    {
  288.     for(int j = i;j < fallingNum - 1;j ++)
  289.     {
  290.     fallingPara[j][0] = fallingPara[j + 1][0];
  291.     fallingPara[j][1] = fallingPara[j + 1][1];
  292.     fallingPara[j][2] = fallingPara[j + 1][2];
  293.     }
  294.     fallingNum--;
  295.    }
  296.   }
  298.  }
  300.  private void paoPaoMoving()
  301.  {
  302. int posX = 0;
  303. int posY = 0;
  304. int preX;
  305. int preY;
  306. int pre_x;
  307. int pre_y;
  308. preX = nowX;
  309. preY = nowY;
  310. pre_x = nowX;
  311. pre_y = nowY;
  312. if(hitted)
  313.    {
  314.    hitted = !hitted;
  315.    dealWithHit(hittedI,hittedJ);
  316.    return;
  317.    }
  318.    timeCount ++;
  319.    posX = startX + (timeCount * v) * angleCosValue / 100000;
  320.    posY = startY - (timeCount * v) * angleSinValue / 100000;
  321.    while(true)
  322.    {
  323.    if(posX  - 8 < 0)
  324.       {
  325.      startX = 8;
  326.      startY = nowY;
  327.      nowX   = 8;
  328.      timeCount = 0;
  329.      angleCosValue = 0 - angleCosValue;
  330.      //timeCount ++;
  331.      break;
  332.       }
  333.    else if(posX + 8 > paintW)
  334.       {
  335.      startX = paintW - 8;
  336.      startY = nowY;
  337.      nowX   = paintW - 8;
  338.      timeCount = 0;
  339.      angleCosValue = 0 - angleCosValue;
  340.      //timeCount ++;
  341.      break;
  342.       }
  343.    else if(posY - 8 <= 0)                      //reach the top
  344.       {
  345.      this.roundPara[0][posX / 16] = isMovingColor;
  346.      nowX = posX;
  347.      nowY = 8;
  348.      checkConnect(0,nowX / 16,isMovingColor);
  349.      if(checkDisappear())
  350.        checkFall();
  351.      isMoving = false;
  352.      return;
  353.       }
  354.    else
  355.       {
  356.       nowX = posX;
  357.       nowY = posY;
  358.       break;
  359.       }
  360.    }
  362.    if(nowY == 8)
  363.      return;
  365.    for(int i = 0;i < 10; i ++)
  366.       {
  367.    if(i % 2 == 0)
  368.         {
  369.       for(int j = 0;j < 8;j ++)
  370.          {
  371.      if(isCollided(nowX,nowY,j * 16 + 8,i * 14 + 8) && roundPara[i][j] > 0 && roundPara[i][j] < 9)
  372.           {
  373.             for(int m = 1;m <= v;m ++)
  374.                        {
  376.              preX = startX + ((timeCount - 1) * v + m) * angleCosValue / 100000;
  377.              preY = startY - ((timeCount - 1) * v + m) * angleSinValue / 100000;
  378.               if(isCollided(preX,preY,j * 16 + 8,i * 14 + 8))
  379.                          {
  380.                 hitted = true;
  381.                 nowX = preX;
  382.                 nowY = preY;
  383.                 hittedI = i;
  384.                 hittedJ = j;
  385.                 break;
  386.                          }
  387.                        }
  388.             return;
  389.           }
  390.          }
  391.         }
  392.    else if(i % 2 == 1)
  393.         {
  394.           for(int j = 0;j < 7; j ++)
  395.           {
  396.      if(isCollided(nowX,nowY,8 + j * 16 + 8,i * 14 + 8) && roundPara[i][j] > 0 && roundPara[i][j] < 9)
  397.             {
  399.               for(int m = 1;m <= v;m ++)
  400.                                    {
  402.               preX = startX + ((timeCount - 1) * v + m) * angleCosValue / 100000;
  403.               preY = startY - ((timeCount - 1) * v + m) * angleSinValue / 100000;
  404.               if(isCollided(preX,preY,8 + j * 16 + 8,i * 14 + 8))
  405.                                      {
  406.                           hitted = true;
  407.                           nowX = preX;
  408.                           nowY = preY;
  409.                           hittedI = i;
  410.                           hittedJ = j;
  411.                             break;
  412.                                      }
  413.                                    }
  414.                return;
  415.             }
  416.           }
  417.         }
  419.       }       //for(int i = 0;i < 10; i ++)
  421.  }
  422. private boolean checkDisappear()
  423.  {
  424. int sameColorCount = 0;
  425.  for(int i = 0;i < 10;i ++)
  426.    if(i % 2 == 0)
  427.    {
  428. for(int j = 0 ;j < 8 ;j ++)
  429.        if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
  431.          sameColorCount ++;
  432.    }
  433.    else if(i % 2 == 1)
  434.    {
  435.       for(int j = 0;j < 7;j ++)
  436.         if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
  437.           sameColorCount ++;
  438.    }
  439. if(sameColorCount >= 3)
  440.    {
  441. score += sameColorCount;
  442. disappearCount = 5;
  443. /*
  444. for(int i = 0;i < 10;i ++)
  445.      {
  446.      for(int j = 0;j < (i % 2 == 0 ? 8 : 7);j ++)
  447.       {
  448.       if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
  449.         roundPara[i][j] = 0;
  450.       }
  451.      }
  452. */
  453. return true;
  454.    }
  455.    for(int i = 0;i < 10;i ++)
  456.         {
  457.         for(int j = 0;j < (i % 2 == 0 ? 8 : 7);j ++)
  458.          {
  459.          if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
  460.            roundPara[i][j] -= 8;
  461.          }
  462.         }
  464.  return false;
  465.  }
  466. private void checkConnect(int x,int y,int color)         //let all round have the same color disappear
  467.  {
  468. if(x == 10 && haveNoSameRound(x,y,color))
  469.    {
  470.      overThread = true;
  471.      return;
  472.    }
  473. if(roundPara[x][y] == color)
  474.      roundPara[x][y] += 8;
  475. if(haveNoSameRound(x,y,color))
  476.      return;
  477. else
  478.    {
  479.    if(x == 9)
  480.    {
  481.    if(y == 0)
  482.     {
  483.      if(roundPara[9][1] == color)
  484.      checkConnect(9,1,color);
  485.      if(roundPara[8][1] == color)
  486.      checkConnect(8,1,color);
  487.      if(roundPara[8][2] == color)
  488.        checkConnect(8,2,color);
  489.     }
  490.    else if(y == 6)
  491.     {
  492. if(roundPara[9][7] == color)
  493.         checkConnect(10,6,color);
  494. if(roundPara[8][6] == color)
  495.         checkConnect(8,6,color);
  496.     }
  497.    else
  498.     {
  499.    if(roundPara[8][y] == color)
  500.      checkConnect(8,y,color);
  501.   if(roundPara[8][y + 1] == color)
  502.     checkConnect(8,y + 1,color);
  503.    if(roundPara[9][y - 1] == color)
  504.      checkConnect(9,y - 1,color);
  505.    if(roundPara[9][y + 1] == color)
  506.      checkConnect(9,y + 1,color);
  507.     if(roundPara[10][y] == color)
  508.       checkConnect(10,y,color);
  509.     if(roundPara[10][y + 1] == color)
  510.       checkConnect(10,y + 1,color);
  511.     }
  512.    }            //if(x == 10)
  513. else if(x == 0)                              //the first row
  514.    {
  515.    if(y == 0)
  516.       {
  517. if(roundPara[0][1] == color)
  518.    checkConnect(0,1,color);
  519. if(roundPara[1][0] == color)
  520.    checkConnect(1,0,color);
  521.       }
  522.    else if(y == 7)
  523.       {
  524.       if(roundPara[0][6] == color)
  525.         checkConnect(0,6,color);
  526.       if(roundPara[1][6] == color)
  527.         checkConnect(1,6,color);
  528.       }
  529.    else
  530.      {
  531.      if(roundPara[x][y - 1] == color)
  532.        checkConnect(x,y - 1,color);
  533.      if(roundPara[x][y + 1] == color)
  534.        checkConnect(x,y + 1,color);
  535.      if(roundPara[x + 1][y - 1] == color)
  536.        checkConnect(x + 1,y - 1,color);
  537.      if(roundPara[x + 1][y] == color)
  538.        checkConnect(x + 1,y,color);
  539.      }
  540.    }
  541. else if(y == 0)
  542.    {
  543.   if(x % 2 == 1)
  544.      {
  545.     if(roundPara[x - 1][y] == color)
  546.       checkConnect(x - 1,y,color);
  547.     if(roundPara[x - 1][y + 1] == color)
  548.       checkConnect(x- 1,y + 1,color);
  549.     if(roundPara[x][y + 1] == color)
  550.       checkConnect(x,y + 1,color);
  551.     if(roundPara[x + 1][y] == color)
  552.       checkConnect(x + 1,y,color);
  553.     if(roundPara[x + 1][y + 1] == color)
  554.       checkConnect(x + 1,y + 1,color);
  555.      }
  556.   else if(x % 2 == 0)
  557.      {
  558. if(roundPara[x - 1][y] == color)
  559.          checkConnect(x - 1,y,color);
  560. if(roundPara[x][y + 1] == color)
  561.          checkConnect(x, y + 1,color);
  562. if(roundPara[x + 1][y] == color)
  563.          checkConnect(x + 1,y ,color);
  564.      }
  565.    }
  566. else if(y == 6 && x % 2 == 1)
  567.    {
  568. if(roundPara[x - 1][y] == color)
  569.        checkConnect(x - 1,y,color);
  570. if(roundPara[x - 1][y + 1] == color)
  571.        checkConnect(x - 1,y + 1,color);
  572. if(roundPara[x][y - 1] == color)
  573.        checkConnect(x,y - 1,color);
  574. if(roundPara[x + 1][y] == color)
  575.        checkConnect(x + 1,y,color);
  576. if(roundPara[x + 1][y + 1] == color)
  577.        checkConnect(x + 1,y + 1,color);
  578.    }
  579. else if(y == 7 && x % 2 == 0)
  580.    {
  581. if(roundPara[x - 1][y - 1] == color)
  582.        checkConnect(x - 1,y - 1,color);
  583. if(roundPara[x][y - 1] == color)
  584.        checkConnect(x,y - 1,color);
  585. if(roundPara[x + 1][y - 1] == color)
  586.        checkConnect(x + 1,y - 1,color);
  587.    }
  588. else
  589.    {
  590.    if(x % 2 == 0)
  591.      {
  592. if(roundPara[x - 1][y] == color)
  593.          checkConnect(x - 1,y,color);
  594. if(roundPara[x - 1][y - 1] == color)
  595.          checkConnect(x - 1,y - 1,color);
  596. if(roundPara[x][y - 1] == color)
  597.          checkConnect(x,y - 1,color);
  598. if(roundPara[x][y + 1] == color)
  599.          checkConnect(x,y + 1,color);
  600. if(roundPara[x + 1][y] == color)
  601.          checkConnect(x + 1,y,color);
  602. if(roundPara[x + 1][y - 1] == color)
  603.          checkConnect(x + 1,y - 1,color);
  605.      }
  606.    else if(x % 2 == 1)
  607.      {
  608.        if(roundPara[x - 1][y] == color)
  609.                 checkConnect(x - 1,y,color);
  610.        if(roundPara[x - 1][y + 1] == color)
  611.                 checkConnect(x - 1,y + 1,color);
  612.        if(roundPara[x][y - 1] == color)
  613.                 checkConnect(x,y - 1,color);
  614.        if(roundPara[x][y + 1] == color)
  615.                 checkConnect(x,y + 1,color);
  616.        if(roundPara[x + 1][y] == color)
  617.                 checkConnect(x + 1,y,color);
  618.        if(roundPara[x + 1][y + 1] == color)
  619.                 checkConnect(x + 1,y + 1,color);
  621.      }
  623.     }
  624.    }
  625.                           //
  626.  }
  627. private void checkFall()
  628.  {
  629. int color;
  630. for(int i = 0;i < 10;i ++)            //have no connectting with the top wall
  631.    {
  632.        if(i % 2 == 0)
  633.      {
  634. for(int j = 0;j < 8 ;j ++)
  635.        {
  636. color = roundPara[i][j];
  637.   if(roundPara[i][j] > 0 && roundPara[i][j] < 9 && !connectWithTopWall(i,j))
  638.          {
  639.            fallingNum ++;
  640.            score ++;
  641.            roundPara[i][j] = 0;
  642.          fallingPara[fallingNum - 1][0] = color;
  643.          fallingPara[fallingNum - 1][1] = 16 * j + 8;
  644.          fallingPara[fallingNum - 1][2] = 14 * i + 8;
  645.         }
  646.         for(int x = 0;x < 10;x ++)
  647.                  {
  648.                    for(int y = 0;y < (x % 2 == 0 ? 8 : 7);y ++)
  649.                   if(roundPara[x][y] > 16 && roundPara[x][y] < 25)
  650.                     roundPara[x][y] = roundPara[x][y] - 16;
  651.                  }
  652.        }
  653.      }
  654. else if(i % 2 == 1)
  655.      {
  656. for(int j = 0;j < 7;j ++)
  657.        {
  658. color = roundPara[i][j];
  659.      if(roundPara[i][j] > 0 && roundPara[i][j] < 9 && !connectWithTopWall(i,j))
  660.          {
  661.            fallingNum ++;
  662.            score ++;
  663.            roundPara[i][j] = 0;
  664.            fallingPara[fallingNum - 1][0] = color;
  665.            fallingPara[fallingNum - 1][1] = 16 * j + 8;
  666.            fallingPara[fallingNum - 1][2] = 14 * i + 8;
  668.          }
  669.          for(int x = 0;x < 10;x ++)
  670.                     {
  671.                       for(int y = 0;y < (x % 2 == 0 ? 8 : 7);y ++)
  672.                       if(roundPara[x][y] > 16 && roundPara[x][y] < 25)
  673.                         roundPara[x][y] = roundPara[x][y] - 16;
  674.                     }
  676.        }
  677.      }
  678.    }                  //for(int i = 1;i < 10;i ++)
  679. for(int m = 0;m < 10;m ++)
  680.    {
  681.      for(int n = 0;n < (m % 2 == 0 ? 8 : 7);n ++)
  682.        System.out.print(roundPara[m][n]);
  683.    }
  684.  }
  685. private boolean connectWithTopWall(int i,int j)
  686.  {
  687. if(i == 0 && roundPara[i][j] > 0 && roundPara[i][j] < 9)
  688.      return true;
  689. else   if(roundPara[i][j] > 0 && roundPara[i][j] < 9)
  690.          {
  691.         roundPara[i][j] += 16;
  692.   if(i == 9)
  693.    {
  694.    if(j == 0)
  695.     {
  696.     if(connectWithTopWall(8,0) || connectWithTopWall(8,1) || connectWithTopWall(9,1))
  697.       return true;
  698.     }
  699.    else if(j == 6)
  700.     {
  701.      if(connectWithTopWall(8,6) || connectWithTopWall(8,7) || connectWithTopWall(9,5))
  702.      return true;
  703.     }
  704.    else if(connectWithTopWall(9,j - 1) || connectWithTopWall(9,j + 1)
  705.          ||connectWithTopWall(8,j) || connectWithTopWall(8,j + 1))
  706.      return true;
  707.    }
  708. else if(i == 0)
  709.    {
  711.    }
  712. else if(j == 0)
  713.    {
  714.   if(i % 2 == 1)
  715.      {
  716.        if(connectWithTopWall(i - 1,j + 1) || connectWithTopWall(i - 1,j)
  717.        ||connectWithTopWall(i,j + 1)
  718.        ||connectWithTopWall(i + 1,j + 1) || connectWithTopWall(i + 1,j))
  719.     return true;
  720.      }
  721.   else if(i % 2 == 0)
  722.      {
  723.      if(connectWithTopWall(i - 1,j)
  724.      || connectWithTopWall(i,j + 1) ||
  725.      connectWithTopWall(i + 1,j))
  726.        return true;
  727.      }
  728.    }
  729. else if(j == 6 && i % 2 == 1)
  730.    {
  731. if(connectWithTopWall(i - 1,j) || connectWithTopWall(i - 1,j + 1)
  732.    || connectWithTopWall(i,j - 1)
  733.    || connectWithTopWall(i + 1,j) || connectWithTopWall(i + 1,j + 1))
  734.       return true;
  735.    }
  736. else if(j == 7 && i % 2 == 0)
  737.    {
  738.    if(connectWithTopWall(i,j - 1)
  739.    || connectWithTopWall(i - 1,j - 1)
  740.    || connectWithTopWall(i + 1,j - 1))
  741.      return true;
  742.    }
  743. else
  744.    {
  745.    if(i % 2 == 0)
  746.      {
  747.      if(connectWithTopWall(i - 1,j - 1)|| connectWithTopWall(i - 1,j)
  748.         || connectWithTopWall(i, j - 1) || connectWithTopWall(i, j + 1)
  749.         || connectWithTopWall(i + 1,j - 1) || connectWithTopWall(i + 1, j))
  750.     return true;
  751.      }
  752.    else if(i % 2 == 1)
  753.      {
  754.      if(connectWithTopWall(i - 1,j) || connectWithTopWall(i - 1,j + 1)
  755.         || connectWithTopWall(i, j - 1) || connectWithTopWall(i,j + 1)
  756.         || connectWithTopWall(i + 1,j) || connectWithTopWall(i + 1,j + 1))
  757.      return true;
  758.      }
  759.    }
  760.  return false;
  761.  }
  762. else return false;
  763.  }
  764. private boolean haveNoSameRound(int x,int y,int color)
  765.  {
  766. if(x == 10)
  767.    {
  768.     if(roundPara[9][y - 1] == color || roundPara[9][y] == color)
  769.      return false;
  770.    }
  771. else if(x == 0)                              //the first row
  772.    {
  773.    if(y == 0)
  774.       {
  775.       if(roundPara[0][1] == color || roundPara[1][0] == color)
  776.         return false;
  777.       }
  778.    else if(y == 7)
  779.       {
  780.       if(roundPara[0][6] == color || roundPara[1][6] == color)
  781.         return false;
  782.       }
  783.    else if(roundPara[0][y - 1] == color || roundPara[0][y + 1] == color
  784.         || roundPara[1][y] == color || roundPara[1][y - 1] == color)
  785.         return false;
  786.    }
  787. else if(y == 0)
  788.    {
  789.   if(x % 2 == 1)
  790.      {
  791.     if(roundPara[x - 1][y] == color || roundPara[x - 1][y + 1] == color || roundPara[x][y + 1] == color
  792.     ||roundPara[x + 1][y] == color || roundPara[x + 1][y + 1] == color)
  793.     return false;
  794.      }
  795.   else if(x % 2 == 0)
  796.      {
  797.      if(roundPara[x - 1][y] == color || roundPara[x][y + 1] == color || roundPara[x + 1][y] == color)
  798.        return false;
  799.      }
  800.    }
  801. else if(y == 6 && x % 2 == 1)
  802.    {
  803.    if(roundPara[x][y - 1] == color || roundPara[x - 1][y] == color || roundPara[x - 1][y + 1] == color
  804.     ||roundPara[x + 1][y] == color || roundPara[x + 1][y + 1] == color)
  805.    return false;
  806.    }
  807. else if(y == 7 && x % 2 == 0)
  808.    {
  809.    if(roundPara[x][y - 1] == color || roundPara[x - 1][y - 1] == color || roundPara[x + 1][y - 1] == color)
  810.      return false;
  811.    }
  812. else
  813.    {
  814.    if(x % 2 == 0)
  815.      {
  816.      if(roundPara[x - 1][y - 1] == color || roundPara[x - 1][y] == color || roundPara[x][ y - 1] == color
  817.       ||roundPara[x][y + 1] == color || roundPara[x + 1][y - 1] == color || roundPara[x + 1][y] == color)
  818.     return false;
  819.      }
  820.    else if(x % 2 == 1)
  821.      {
  822.      if(roundPara[x - 1][y] == color || roundPara[x - 1][y + 1] == color || roundPara[x][y - 1] == color
  823.       ||roundPara[x][y + 1] == color || roundPara[x + 1][y] == color || roundPara[x + 1][y + 1] == color)
  824.      return false;
  825.      }
  826.    }         //else
  827. return true;
  828.  }
  831.  private void dealWithHit(int i,int j)
  832.   {
  833. int a = 8 << 1;
  834.     if(nowX == paintW - 8)
  835.         {
  836.         if(i % 2 == 0)
  837.         {
  838.           roundPara[i + 1][j - 1] = isMovingColor;
  839.          checkConnect(i + 1,j - 1,isMovingColor);
  840.         }
  841.         else
  842.          {
  843.           roundPara[i + 1][j + 1] = isMovingColor;
  844.           checkConnect(i + 1,j + 1,isMovingColor);
  845.          }
  846.         }
  847.     else if(nowX == 8)
  848.         {
  849.         roundPara[i + 1][0] = isMovingColor;
  850.         checkConnect(i + 1,0,isMovingColor);
  851.         }
  852.     else if(i % 2 == 0)
  853.        {
  854.      if(nowX < 8 + j * 16)                   //left
  855.         {
  856.     if(j >= 1 && Math.abs(nowY - (i * 14 + 8)) < localStand && roundPara[i][j - 1] == 0)
  857.           {
  858.             roundPara[i][j - 1] = isMovingColor;
  859.             checkConnect(i,j - 1,isMovingColor);
  860.           }
  861.     else  if(roundPara[i + 1][j - 1] == 0)
  862.           {
  863.             roundPara[i + 1][j - 1] = isMovingColor;
  864.           checkConnect(i + 1,j - 1,isMovingColor);
  865.         }
  866.     else  {
  867. //if(roundPara[i][j - 1] == 0)
  868.      // {
  869.       //  roundPara[i][j - 1] = isMovingColor;
  870. //checkConnect(i,j - 1,isMovingColor);
  871.       //}
  872. //else
  873.         {
  874.           roundPara[i + 1][j] = isMovingColor;
  875.           checkConnect(i + 1,j,isMovingColor);
  876.         }
  877.           }
  879.          }
  880.    else if(nowX >= 8 + j * 16)
  881.         {
  882.           if(j <= 6 && Math.abs(nowY - (i * 14 + 8)) < localStand && roundPara[i][j + 1] == 0)
  883.                 {
  884.                   roundPara[i][j + 1] = isMovingColor;
  885.                   checkConnect(i,j + 1,isMovingColor);
  886.                 }
  887.           else if(roundPara[i + 1][j] == 0) {
  888.                 roundPara[i + 1][j] = isMovingColor;
  889.                 checkConnect(i + 1,j,isMovingColor);
  890.                  }
  891.            else{
  892.              roundPara[i + 1][j - 1] = isMovingColor;
  893.              checkConnect(i + 1,j - 1,isMovingColor);
  894.                }
  895.         }
  896.        }
  897.       else if(i % 2 == 1)
  898.        {
  900.          if(nowX < 8 + j * 16 + 8)                   //left
  901.          {
  902.             if(j >= 1 && Math.abs(nowY - (i * 14 + 8)) < localStand && roundPara[i][j - 1] == 0)
  903.             {
  904.             roundPara[i][j - 1] = isMovingColor;
  905.             checkConnect(i,j - 1,isMovingColor);
  906.             }
  907.            else if(j >= 0 && roundPara[i + 1][j] == 0)
  908.            {
  909.              roundPara[i + 1][j] = isMovingColor;
  910.              checkConnect(i + 1,j,isMovingColor);
  911.            }
  912.            else
  913.            {
  914.            roundPara[i + 1][j + 1] = isMovingColor;
  915.         checkConnect(i + 1,j + 1,isMovingColor);
  916.          }
  918.           }
  919.          else if(nowX >= 8 + j * 16 + 8)
  920.             {
  921.       if(j <= 5 && Math.abs(nowY - (i * 14 + 8)) < localStand && roundPara[i][j + 1] == 0)      //down
  922.                {
  923.                  roundPara[i][j + 1] = isMovingColor;
  924.                  checkConnect(i,j + 1,isMovingColor);
  925.                }
  927.             else  if(roundPara[i + 1][j + 1] == 0)
  928.               {
  929.                 roundPara[i + 1][j + 1] = isMovingColor;
  930.                 checkConnect(i + 1,j + 1,isMovingColor);
  931.               }
  933.               else
  934.               {
  935.                 roundPara[i + 1][j] = isMovingColor;
  936.                 checkConnect(i + 1,j,isMovingColor);
  937.               }
  939.             }
  940.        }
  941.      for(int x = 0;x < 10;x ++)
  942.      {
  943.        for(int y = 0;y < (x % 2 == 0 ? 8 : 7);y ++)
  944.          System.out.print(roundPara[x][y]);
  945.      }
  946.        if(checkDisappear())            // if this round three or more ball disappeared
  947.        checkFall();
  948.        isMoving = false;
  950.   }                                       //dealWithHit()
  951. private boolean gameOver()
  952.   {
  953. for(int i = 11 - nowTop;i < 12;i ++)
  954.     {
  955. for(int j = 0;j < (i % 2 == 0 ? 8 : 7);j ++)
  956. if(roundPara[i][j] > 0 && roundPara[i][j] < 9)
  957.             return true;
  958.     }
  959. return false;
  960.   }
  961. private boolean isCollided(int x1,int y1,int x2,int y2)
  962.  {
  963.  if((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) <= (8 + effectiveR) * (8 + effectiveR))
  964.      return true;
  965.  else return false;
  966.  }
  967.   /** Required paint implementation */
  968. protected void paint(Graphics g)
  969.   {
  970. g.setColor(0,0,0);
  971. g.fillRect(0,0,screenW,screenH);
  972. drawBackGround(g);
  973. g.translate(7,3);
  974. g.setClip(0,0,paintW,paintH);
  975. DirectGraphics dg = DirectUtils.getDirectGraphics(g);
  976. drawForeGround(g,dg);
  977.    /** @todo Add paint codes */
  978.   }
  979. private void addBalls(int floors)
  980.   {
  981.   for(int i = 0;i < 8;i ++)           //往最底层加上一层泡泡
  982.    {
  983.    for(int j = 10;j > 0;j --)
  984.       {
  985.       if(roundPara[i][j] != 0)
  986.          {
  987.            if(i % 2 == 0)
  988.             {
  989. if(roundPara[i][j + 1] == 0)
  990.                 addOneBall(i,j + 1);
  991.                 break;
  992.             }
  993.             else if(i % 2 == 1)                        // i % 2 == 1
  994.             {
  995. roundPara[i + 1][j - 1] = roundPara[i + 1][j - 1] == 0 ? 1 + (((Resource.random.nextInt() % 8)<<1)>>1) : roundPara[i + 1][j - 1];
  996. roundPara[i + 1][j] = roundPara[i + 1][j] == 0 ? 1 + (((Resource.random.nextInt() % 8) << 1)>>1) : roundPara[i + 1][j] ;
  997.             }
  998.          }
  999.        }
  1000.    }
  1001.   }
  1002. private void addOneBall(int x,int y)
  1003.   {
  1004.   if(
  1005.       (x % 2 == 0 && y < 8 && roundPara[x][y] == 0) ||
  1006.       (x % 2 == 1 && y < 7 && roundPara[x][y] == 0)
  1007.     )
  1009.      roundPara[x][y] = 1 + Math.abs(Resource.random.nextInt() % 8);
  1011.   }
  1012. private void drawScore(Graphics g)
  1013.   {
  1014. g.setClip(102,192,74,16);
  1015. g.setColor(100,255,100);
  1016. g.drawString("score:"+ score,104,194,Graphics.LEFT | Graphics.TOP);
  1017. g.setClip(0,0,176,208);
  1018.   }
  1019. private void drawPaoPao(Graphics g)
  1020.   {
  1021.   for(int i = 0;i < 11;i ++)
  1022.     {
  1023.        if(i % 2 == 0)
  1024.         for(int j = 0;j < 8;j ++)
  1025.         {
  1026.      if(roundPara[i][j] > 0 && roundPara[i][j] < 9)
  1027.           {
  1028.       g.setClip(16 * j,14 * i,16,16);
  1029.       g.drawImage(Resource.getImage(Resource.BALL),
  1030.       j * 16  - (roundPara[i][j] - 1) * 16 +(shaking ? shakeOffX[shakeCount]:0),
  1031.       i * 14 ,Graphics.LEFT | Graphics.TOP);
  1032.       g.setClip(0,0,paintW,paintH);
  1033.           }
  1034.       else if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
  1035.       {
  1036.       g.setClip(16 * j,14 * i,16,16);
  1037.       switch(disappearCount)
  1038.       {
  1039.       case 5:
  1040.         g.drawImage(Resource.getImage(Resource.BALL),
  1041.         j * 16  - (roundPara[i][j] - 8 - 1) * 16 +(shaking ? shakeOffX[shakeCount]:0),
  1042.         i * 14 ,Graphics.LEFT | Graphics.TOP);
  1043.       break;
  1044.       case 4:
  1045.       case 3:
  1046.       case 2:
  1047.       case 1:
  1048.         g.drawImage(Resource.getImage(Resource.BALL),
  1049.           j * 16  - (15 - disappearCount / 3) * 16 +(shaking ? shakeOffX[shakeCount]:0),
  1050.           i * 14 ,Graphics.LEFT | Graphics.TOP);
  1051.       break;
  1052.       default:
  1053.       break;
  1054.       }
  1055.       g.setClip(0,0,paintW,paintH);
  1056.       }
  1057.          }
  1058.          else  if(i % 2 == 1)
  1059.          for( int j = 0;j < 7 ; j ++)
  1060.          {
  1061.          if(roundPara[i][j] > 0 && roundPara[i][j] < 9)
  1062.           {
  1063.          g.setClip(8 + 16 * j,14 * i,16,16);
  1064.          g.drawImage(Resource.getImage(Resource.BALL),
  1065.          8 + 16 * j - (roundPara[i][j] - 1) * 16 + (shaking ? shakeOffX[shakeCount]:0),
  1066.          i * 14 ,Graphics.TOP | Graphics.LEFT);
  1067.          g.setClip(0,0,paintW,paintH);
  1068.           }
  1069.          else if(roundPara[i][j] > 8 && roundPara[i][j] < 17)
  1070.            {
  1071.              g.setClip(16 * j + 8,14 * i,16,16);
  1072.                   switch(disappearCount / 3)
  1073.                   {
  1074.                   case 5:
  1075.                     g.drawImage(Resource.getImage(Resource.BALL),
  1076.                     j * 16 + 8 - (roundPara[i][j] - 8 - 1) * 16 +(shaking ? shakeOffX[shakeCount]:0),
  1077.                     i * 14 ,Graphics.LEFT | Graphics.TOP);
  1078.                   break;
  1079.                   case 4:
  1080.                   case 3:
  1081.                   case 2:
  1082.                   case 1:
  1083.                     g.drawImage(Resource.getImage(Resource.BALL),
  1084.                       j * 16 + 8 - (15 - disappearCount / 3) * 16 +(shaking ? shakeOffX[shakeCount]:0),
  1085.                       i * 14 ,Graphics.LEFT | Graphics.TOP);
  1086.                   break;
  1087.                   default:
  1088.                   break;
  1089.                   }
  1090.                   g.setClip(0,0,paintW,paintH);
  1092.            }
  1093.          }
  1094.      }
  1095.   }
  1096. private void drawForeGround(Graphics g,DirectGraphics dg)
  1097.   {
  1098.         //drawTop(g);
  1099.         drawToBeShoot(g);
  1100.         drawNextOne(g);
  1101.         drawIsMoving(g);
  1102.         drawPointer(dg);
  1103.         drawPaoPao(g);
  1104.         drawFalling(g);
  1105.     if(roundStart)
  1106.     {;}
  1107.     else
  1108.     {
  1109.     if(overThread)
  1110.      {
  1111.     g.setClip(0,paintH - overCount,paintW,overCount);
  1112.     for(int i = 0;i < 12;i ++)
  1113.     for(int j = 0;j < (i % 2 == 0 ? 8 : 7);j ++)
  1114.       if(roundPara[i][j] != 0)
  1115.     g.drawImage(Resource.getImage(Resource.BBALL),j * 16 + 8 + (i % 2 == 0 ? 0 : 8),
  1116.         i * 14,Graphics.VCENTER |Graphics.HCENTER);
  1117.     g.setClip(0,0,paintW,paintH);
  1118.      }
  1119.     else
  1120.      {
  1122.      }
  1124.     }
  1125.     if(roundStart)
  1126.     drawRoundStart(dg);
  1127.   }
  1128. private void drawBackGround(Graphics g)
  1129.   {
  1130. g.drawImage(Resource.getImage(Resource.BG),0,0,Graphics.LEFT | Graphics.TOP);
  1131. drawScore(g);
  1132.   }
  1133. private void drawTop(Graphics g)
  1134.   {
  1136.   }
  1137. private void drawPointer(DirectGraphics dg)
  1138.   {
  1139. if(angle <= 90)
  1140. dg.drawImage(Resource.getImage(angle / 6),71 - orgX,170 - orgY,
  1141.              Graphics.VCENTER | Graphics.HCENTER,0);
  1142. else if(angle >= 90)
  1143. dg.drawImage(Resource.getImage((180 - angle) / 6),71 - orgX,170 - orgY,
  1144.              Graphics.VCENTER | Graphics.HCENTER,
  1145.              DirectGraphics.FLIP_HORIZONTAL);
  1147.   }
  1148. private void drawIsMoving(Graphics g)
  1149.   {
  1150. if(isMoving)
  1151.     {
  1152. g.setClip(nowX - 8,nowY - 8,16,16);
  1153. g.drawImage(Resource.getImage(Resource.BALL),nowX - 8 - (isMovingColor - 1) * 16,nowY - 8,Graphics.LEFT | Graphics.TOP);
  1154. g.setClip(0,0,paintW,paintH);
  1155.     }
  1156.   }
  1157. private void drawToBeShoot(Graphics g)
  1158.   {
  1159. g.setClip(71 - orgX - 8,170 - orgY - 8,16,16);
  1160. g.drawImage(Resource.getImage(Resource.BALL),71 - orgX - 8 - (toBeShootColor - 1) * 16,
  1161.                 170 - orgY - 8,Graphics.LEFT | Graphics.TOP);
  1162. g.setClip(0,0,paintW,paintH);
  1163.   }
  1164. private void drawNextOne(Graphics g)
  1165.   {
  1166. g.setClip(54 - orgX - 8,190 - orgY - 16,16,16);
  1167. g.drawImage(Resource.getImage(Resource.BALL),54 - orgX - 8 - (nextOneColor - 1) * 16,
  1168.                 190 - orgY - 16,Graphics.TOP | Graphics.LEFT);
  1169. g.setClip(0,0,paintW,paintH);
  1170.   }
  1171. private void drawFalling(Graphics g)
  1172.   {
  1173.   if(fallingNum > 0)
  1174.    {
  1175.      for(int i = 0;i < fallingNum;i ++)
  1176.       {
  1177.       g.setClip(fallingPara[i][1] - 8,fallingPara[i][2] - 8,16,16);
  1178.       g.drawImage(Resource.getImage(Resource.BALL),
  1179.                   fallingPara[i][1]  - 8 - 16 * (fallingPara[i][0] - 1),
  1180.                   fallingPara[i][2] - 8,Graphics.LEFT | Graphics.TOP);
  1181.       g.setClip(0,0,paintW,paintH);
  1182.        }
  1183.     }
  1184.   }
  1185. public static void drawRoundStart(Graphics g)
  1186.   {
  1188.   }
  1189. private void drawRoundStart(DirectGraphics dg)
  1190.   {
  1191. if(roundStartCount <= 16)
  1192.     {
  1193.     }
  1194. else if(roundStartCount <= 32)
  1195.     {
  1196. if(roundStartCount >= 48)
  1197.       {
  1199.       }
  1200.     }
  1201. else
  1202.     {
  1203.     }
  1204.   }
  1206. private void drawGameOver(Graphics g)
  1207.   {
  1209.   }
  1210. }