Android--中国象棋

简介:

象棋,很多人多接触过,学者写了一个,大神可以指点一下~直接上代码:

贴出主要代码,想要Demo的点击下载:中国象棋Demo

[java]  view plain  copy
 print ? 在CODE上查看代码片 派生到我的代码片
  1. package wyf.ytl;  
  2.   
  3. import android.content.Context;  
  4. import android.graphics.Bitmap;  
  5. import android.graphics.BitmapFactory;  
  6. import android.graphics.Canvas;  
  7. import android.graphics.Color;  
  8. import android.graphics.Paint;  
  9. import android.media.MediaPlayer;  
  10. import android.view.MotionEvent;  
  11. import android.view.SurfaceHolder;  
  12. import android.view.SurfaceView;  
  13. /** 
  14.  * 该类是整个程序最主要的类,是主游戏的界面 
  15.  * 该界面继承自SurfaceView并实现了SurfaceHolder.Callback接口 
  16.  * 其中包含了一个刷帧的线程类 
  17.  *  
  18.  */  
  19. public class GameView extends SurfaceView implements SurfaceHolder.Callback{  
  20.     private TutorialThread thread;//刷帧的线程  
  21.     TimeThread timeThread ;  
  22.     ChessActivity activity;//声明Activity的引用  
  23.     Bitmap qiPan;//棋盘  
  24.     Bitmap qizibackground;//棋子的背景图片  
  25.     Bitmap win;//胜利的图片  
  26.     Bitmap lost;//失败的图片  
  27.     Bitmap ok;//确定按钮  
  28.     Bitmap vs;//黑方红方VS的图片  
  29.     Bitmap right;//向右的指针  
  30.     Bitmap left;//向左的指针   
  31.     Bitmap current;//“当前”文字  
  32.     Bitmap exit2;//退出按钮图片  
  33.     Bitmap sound2;//声音按钮图片  
  34.     Bitmap sound3;//当前是否播放了声音  
  35.     Bitmap time;//冒号  
  36.     Bitmap redtime;//红色冒号  
  37.     Bitmap background;//背景图片  
  38.     MediaPlayer go;//下棋声音     
  39.     Paint paint;//画笔  
  40.     boolean caiPan = true;//是否为玩家走棋  
  41.     boolean focus = false;//当前是否有选中的棋子  
  42.     int selectqizi = 0//当然选中的棋子  
  43.   
  44.     int startI, startJ;//记录当前棋子的开始位置  
  45.     int endI, endJ;//记录当前棋子的目标位置  
  46.     Bitmap[] heiZi = new Bitmap[7];//黑子的图片数组  
  47.     Bitmap[] hongZi = new Bitmap[7];//红子的图片数组  
  48.     Bitmap[] number = new Bitmap[10];//数字的图片数组,用于显示时间   
  49.     Bitmap[] redNumber = new Bitmap[10];//红色数字的图片,用于显示时间   
  50.       
  51.     GuiZe guiZe;//规则类  
  52.   
  53.     int status = 0;//游戏状态。0游戏中,1胜利, 2失败  
  54.     int heiTime = 0;//黑方总共思考时间  
  55.     int hongTime = 0;//红方总共思考时间   
  56.   
  57.     int[][] qizi = new int[][]{//棋盘  
  58.         {2,3,6,5,1,5,6,3,2},  
  59.         {0,0,0,0,0,0,0,0,0},  
  60.         {0,4,0,0,0,0,0,4,0},  
  61.         {7,0,7,0,7,0,7,0,7},  
  62.         {0,0,0,0,0,0,0,0,0},  
  63.   
  64.         {0,0,0,0,0,0,0,0,0},  
  65.         {14,0,14,0,14,0,14,0,14},  
  66.         {0,11,0,0,0,0,0,11,0},  
  67.         {0,0,0,0,0,0,0,0,0},  
  68.         {9,10,13,12,8,12,13,10,9},  
  69.     };  
  70.       
  71.     public GameView(Context context,ChessActivity activity) {//构造器  
  72.         super(context);  
  73.         this.activity = activity;//得到Activity的引用  
  74.         getHolder().addCallback(this);  
  75.         go  = MediaPlayer.create(this.getContext(), R.raw.go);//加载下棋的声音  
  76.         this.thread = new TutorialThread(getHolder(), this);//初始化刷帧线程  
  77.         this.timeThread = new TimeThread(this);//初始化思考时间的线程  
  78.         init();//初始化所需资源  
  79.         guiZe = new GuiZe();//初始化规则类  
  80.     }  
  81.       
  82.     public void init(){//初始化方法   
  83.         paint = new Paint();//初始化画笔  
  84.         qiPan = BitmapFactory.decodeResource(getResources(), R.drawable.qipan);//棋盘图片  
  85.         qizibackground = BitmapFactory.decodeResource(getResources(), R.drawable.qizi);//棋子的背景  
  86.         win = BitmapFactory.decodeResource(getResources(), R.drawable.win);//胜利的图片  
  87.         lost = BitmapFactory.decodeResource(getResources(), R.drawable.lost);//失败的图片  
  88.         ok = BitmapFactory.decodeResource(getResources(), R.drawable.ok);//确定按钮图片  
  89.         vs = BitmapFactory.decodeResource(getResources(), R.drawable.vs);//vs字样的图片  
  90.         right = BitmapFactory.decodeResource(getResources(), R.drawable.right);//向右的指针  
  91.         left = BitmapFactory.decodeResource(getResources(), R.drawable.left);//向左的指针  
  92.         current = BitmapFactory.decodeResource(getResources(), R.drawable.current);//文字“当前”  
  93.         exit2 = BitmapFactory.decodeResource(getResources(), R.drawable.exit2);//退出按钮图片  
  94.         sound2 = BitmapFactory.decodeResource(getResources(), R.drawable.sound2);//声音按钮图片  
  95.         time = BitmapFactory.decodeResource(getResources(), R.drawable.time);//黑色冒号  
  96.         redtime = BitmapFactory.decodeResource(getResources(), R.drawable.redtime);//红色冒号  
  97.         sound3 = BitmapFactory.decodeResource(getResources(), R.drawable.sound3);  
  98.           
  99.         heiZi[0] = BitmapFactory.decodeResource(getResources(), R.drawable.heishuai);//黑帅  
  100.         heiZi[1] = BitmapFactory.decodeResource(getResources(), R.drawable.heiju);//黑车  
  101.         heiZi[2] = BitmapFactory.decodeResource(getResources(), R.drawable.heima);//黑马  
  102.         heiZi[3] = BitmapFactory.decodeResource(getResources(), R.drawable.heipao);//黑炮  
  103.         heiZi[4] = BitmapFactory.decodeResource(getResources(), R.drawable.heishi);//黑士  
  104.         heiZi[5] = BitmapFactory.decodeResource(getResources(), R.drawable.heixiang);//黑象  
  105.         heiZi[6] = BitmapFactory.decodeResource(getResources(), R.drawable.heibing);//黑兵  
  106.           
  107.         hongZi[0] = BitmapFactory.decodeResource(getResources(), R.drawable.hongjiang);//红将  
  108.         hongZi[1] = BitmapFactory.decodeResource(getResources(), R.drawable.hongju);//红车  
  109.         hongZi[2] = BitmapFactory.decodeResource(getResources(), R.drawable.hongma);//红马  
  110.         hongZi[3] = BitmapFactory.decodeResource(getResources(), R.drawable.hongpao);//红砲  
  111.         hongZi[4] = BitmapFactory.decodeResource(getResources(), R.drawable.hongshi);//红仕  
  112.         hongZi[5] = BitmapFactory.decodeResource(getResources(), R.drawable.hongxiang);//红相  
  113.         hongZi[6] = BitmapFactory.decodeResource(getResources(), R.drawable.hongzu);//红卒  
  114.           
  115.         number[0] = BitmapFactory.decodeResource(getResources(), R.drawable.number0);//黑色数字0  
  116.         number[1] = BitmapFactory.decodeResource(getResources(), R.drawable.number1);//黑色数字1  
  117.         number[2] = BitmapFactory.decodeResource(getResources(), R.drawable.number2);//黑色数字2  
  118.         number[3] = BitmapFactory.decodeResource(getResources(), R.drawable.number3);//黑色数字3  
  119.         number[4] = BitmapFactory.decodeResource(getResources(), R.drawable.number4);//黑色数字4  
  120.         number[5] = BitmapFactory.decodeResource(getResources(), R.drawable.number5);//黑色数字5  
  121.         number[6] = BitmapFactory.decodeResource(getResources(), R.drawable.number6);//黑色数字6  
  122.         number[7] = BitmapFactory.decodeResource(getResources(), R.drawable.number7);//黑色数字7  
  123.         number[8] = BitmapFactory.decodeResource(getResources(), R.drawable.number8);//黑色数字8  
  124.         number[9] = BitmapFactory.decodeResource(getResources(), R.drawable.number9);//黑色数字9  
  125.           
  126.         redNumber[0] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber0);//红色数字0  
  127.         redNumber[1] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber1);//红色数字1  
  128.         redNumber[2] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber2);//红色数字2  
  129.         redNumber[3] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber3);//红色数字3  
  130.         redNumber[4] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber4);//红色数字4  
  131.         redNumber[5] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber5);//红色数字5  
  132.         redNumber[6] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber6);//红色数字6  
  133.         redNumber[7] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber7);//红色数字7  
  134.         redNumber[8] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber8);//红色数字8  
  135.         redNumber[9] = BitmapFactory.decodeResource(getResources(), R.drawable.rednumber9);//红色数字9  
  136.           
  137.         background = BitmapFactory.decodeResource(getResources(), R.drawable.bacnground);  
  138.           
  139.           
  140.     }  
  141.     /** 
  142.      * 该方法是自己定义的并非重写的 
  143.      * 该方法是死的,只根据数据绘制屏幕 
  144.      */  
  145.     public void onDraw(Canvas canvas){//自己写的绘制方法  
  146.         canvas.drawColor(Color.WHITE);  
  147.         canvas.drawBitmap(background, 0,0null);//清背景  
  148.         canvas.drawBitmap(qiPan, 1010null);//绘制棋盘     
  149.         for(int i=0; i<qizi.length; i++){  
  150.             for(int j=0; j<qizi[i].length; j++){//绘制棋子  
  151.                 if(qizi[i][j] != 0){  
  152.                     canvas.drawBitmap(qizibackground, 9+j*3410+i*35null);//绘制棋子的背景                    
  153.                     if(qizi[i][j] == 1){//为黑帅时  
  154.                         canvas.drawBitmap(heiZi[0], 12+j*3413+i*35, paint);  
  155.                     }  
  156.                     else if(qizi[i][j] == 2){//为黑车时  
  157.                         canvas.drawBitmap(heiZi[1], 12+j*3413+i*35, paint);  
  158.                     }  
  159.                     else if(qizi[i][j] == 3){//为黑马时  
  160.                         canvas.drawBitmap(heiZi[2], 12+j*3413+i*35, paint);  
  161.                     }  
  162.                     else if(qizi[i][j] == 4){//为黑炮时  
  163.                         canvas.drawBitmap(heiZi[3], 12+j*3413+i*35, paint);  
  164.                     }  
  165.                     else if(qizi[i][j] == 5){//为黑士时  
  166.                         canvas.drawBitmap(heiZi[4], 12+j*3413+i*35, paint);  
  167.                     }  
  168.                     else if(qizi[i][j] == 6){//为黑象时  
  169.                         canvas.drawBitmap(heiZi[5], 12+j*3413+i*35, paint);  
  170.                     }  
  171.                     else if(qizi[i][j] == 7){//为黑兵时  
  172.                         canvas.drawBitmap(heiZi[6], 12+j*3413+i*35, paint);  
  173.                     }  
  174.                     else if(qizi[i][j] == 8){//为红将时  
  175.                         canvas.drawBitmap(hongZi[0], 12+j*3413+i*35, paint);  
  176.                     }  
  177.                     else if(qizi[i][j] == 9){//为红车时  
  178.                         canvas.drawBitmap(hongZi[1], 12+j*3413+i*35, paint);  
  179.                     }  
  180.                     else if(qizi[i][j] == 10){//为红马时  
  181.                         canvas.drawBitmap(hongZi[2], 12+j*3413+i*35, paint);  
  182.                     }  
  183.                     else if(qizi[i][j] == 11){//为红砲时  
  184.                         canvas.drawBitmap(hongZi[3], 12+j*3413+i*35, paint);  
  185.                     }  
  186.                     else if(qizi[i][j] == 12){//为红仕时  
  187.                         canvas.drawBitmap(hongZi[4], 12+j*3413+i*35, paint);  
  188.                     }  
  189.                     else if(qizi[i][j] == 13){//为红相时  
  190.                         canvas.drawBitmap(hongZi[5], 12+j*3413+i*35, paint);  
  191.                     }  
  192.                     else if(qizi[i][j] == 14){//为红卒时  
  193.                         canvas.drawBitmap(hongZi[6], 12+j*3413+i*35, paint);  
  194.                     }  
  195.                 }  
  196.             }  
  197.         }  
  198.         canvas.drawBitmap(vs, 10360, paint);//绘制VS背景图  
  199.         //绘制黑方的时间  
  200.         canvas.drawBitmap(time, 81411, paint);//绘制冒号  
  201.         int temp = this.heiTime/60;//换算时间  
  202.         String timeStr = temp+"";//转换成字符串  
  203.         if(timeStr.length()<2){//当不足两位时前面填0  
  204.             timeStr = "0" + timeStr;  
  205.         }  
  206.         for(int i=0;i<2;i++){//循环绘制时间  
  207.             int tempScore=timeStr.charAt(i)-'0';  
  208.             canvas.drawBitmap(number[tempScore], 65+i*7412, paint);  
  209.         }  
  210.         //画分钟  
  211.         temp = this.heiTime%60;  
  212.         timeStr = temp+"";//转换成字符串  
  213.         if(timeStr.length()<2){     
  214.             timeStr = "0" + timeStr;//当长度小于2时在前面添加一个0  
  215.         }  
  216.         for(int i=0;i<2;i++){//循环  
  217.             int tempScore=timeStr.charAt(i)-'0';  
  218.             canvas.drawBitmap(number[tempScore], 85+i*7412, paint);//绘制  
  219.         }  
  220.         //开始绘制红方时间  
  221.         canvas.drawBitmap(this.redtime, 262410, paint);//红方的冒号  
  222.         int temp2 = this.hongTime/60;//换算时间  
  223.         String timeStr2 = temp2+"";//转换成字符串  
  224.         if(timeStr2.length()<2){//当不足两位时前面填0  
  225.             timeStr2 = "0" + timeStr2;  
  226.         }  
  227.         for(int i=0;i<2;i++){//循环绘制时间  
  228.             int tempScore=timeStr2.charAt(i)-'0';  
  229.             canvas.drawBitmap(redNumber[tempScore], 247+i*7411, paint);//绘制  
  230.         }  
  231.         //画分钟  
  232.         temp2 = this.hongTime%60;//求出当前的秒数  
  233.         timeStr2 = temp2+"";//转换成字符串  
  234.         if(timeStr2.length()<2){//不足两位时前面用0补  
  235.             timeStr2 = "0" + timeStr2;  
  236.         }  
  237.         for(int i=0;i<2;i++){//循环绘制  
  238.             int tempScore=timeStr2.charAt(i)-'0';  
  239.             canvas.drawBitmap(redNumber[tempScore], 267+i*7411, paint);//绘制时间数字  
  240.         }  
  241.         if(caiPan == true){//当该玩家走棋时,即红方走棋  
  242.             canvas.drawBitmap(right, 155420, paint);//绘制向右的指针  
  243.         }  
  244.         else{//黑方走棋,即电脑走棋时  
  245.             canvas.drawBitmap(left, 120420, paint);//绘制向左的指针  
  246.         }  
  247.           
  248.         canvas.drawBitmap(current, 138445, paint);//绘制当前文字  
  249.         canvas.drawBitmap(sound2, 10440, paint);//绘制声音  
  250.         if(activity.isSound){//如果正在播放声音  
  251.             canvas.drawBitmap(sound3, 80452, paint);//绘制  
  252.         }  
  253.           
  254.         canvas.drawBitmap(exit2, 250440, paint);//绘制退出按钮  
  255.         if(status == 1){//当胜利时  
  256.             canvas.drawBitmap(win, 85150, paint);//绘制胜利图片  
  257.             canvas.drawBitmap(ok, 113240, paint);  
  258.         }  
  259.         if(status == 2){//失败后  
  260.             canvas.drawBitmap(lost, 85150, paint);//绘制失败界面  
  261.             canvas.drawBitmap(ok, 113236, paint);   
  262.         }  
  263.     }  
  264.     /** 
  265.      * 该方法是游戏主要逻辑接口 
  266.      * 接受玩家输入 
  267.      * 根据点击的位置和当前的游戏状态做出相应的处理 
  268.      * 而当需要切换View时,通过给Activity发送Handler消息来处理 
  269.      * 注意的是只取屏幕被按下的事件 
  270.      */  
  271.     @Override  
  272.     public boolean onTouchEvent(MotionEvent event) {//重写的屏幕监听  
  273.         if(event.getAction() == MotionEvent.ACTION_DOWN){//只取鼠标按下的事件  
  274.             if(event.getX()>10&&event.getX()<10+sound2.getWidth()  
  275.                     && event.getY()>440 && event.getY()<440+sound2.getHeight()){//按下了声音按钮  
  276.                 activity.isSound = !activity.isSound;//声音取反  
  277.                 if(activity.isSound){//当需要放声音时  
  278.                     if(activity.gamesound != null){//gamesound不为空时  
  279.                         if(!activity.gamesound.isPlaying()){//当前没有音乐时  
  280.                             activity.gamesound.start();//播放音乐  
  281.                         }  
  282.                     }  
  283.                 }  
  284.                 else{  
  285.                     if(activity.gamesound != null){//gamesound不为空时  
  286.                         if(activity.gamesound.isPlaying()){//当前有音乐时  
  287.                             activity.gamesound.pause();//停止音乐  
  288.                         }  
  289.                     }   
  290.                 }  
  291.             }//end 按下了声音按钮   
  292.             if(event.getX()>250&&event.getX()<250+exit2.getWidth()  
  293.                     && event.getY()>440 && event.getY()<440+exit2.getHeight()){//按下了退出按钮  
  294.                 activity.myHandler.sendEmptyMessage(1);//发送消息,切换到MenuView  
  295.             }  
  296.             if(status == 1){//胜利后   
  297.                 if(event.getX()>135&&event.getX()<190  
  298.                         && event.getY()>249 && event.getY()<269){//点击了确定按钮  
  299.                     activity.myHandler.sendEmptyMessage(1);//发送消息,切换到MenuView  
  300.                 }  
  301.             }  
  302.             else if(status == 2){//失败后  
  303.                 if(event.getX()>135&&event.getX()<190  
  304.                         && event.getY()>245 && event.getY()<265){//点击了确定按钮  
  305.                     activity.myHandler.sendEmptyMessage(1);//发送消息,切换到MenuView  
  306.                 }  
  307.             }  
  308.             /** 
  309.              * 游戏过程中的逻辑处理 
  310.              * 当点击棋盘时,先判断当前是否为玩家走棋, 
  311.              * 然后再判断当然玩家是否已经有选中的棋子,如果没有则选中 
  312.              * 如果之前有选中的棋子,再判断点击的位置是空地、对方棋子还是自己的棋子 
  313.              * 是空地判断是否可走 
  314.              * 是对方棋子同样判断是否可以走,能走自然吃子 
  315.              * 是自己的棋子则选中该棋子 
  316.              */  
  317.             else if(status == 0){//游戏中时   
  318.                 if(event.getX()>10&&event.getX()<310  
  319.                         && event.getY()>10 && event.getY()<360){//点击的位置在棋盘内时  
  320.                         if(caiPan == true){//如果是该玩家走棋  
  321.                             int i = -1, j = -1;  
  322.                             int[] pos = getPos(event);//根据坐标换算成所在的行和列  
  323.                             i = pos[0];  
  324.                             j = pos[1];  
  325.                             if(focus == false){//之前没有选中的棋子  
  326.                                 if(qizi[i][j] != 0){//点击的位置有棋子  
  327.                                     if(qizi[i][j] > 7){//点击的是自己的棋子。即下面的黑色棋子  
  328.                                         selectqizi = qizi[i][j];//将该棋子设为选中的棋子  
  329.                                         focus = true;//标记当前有选中的棋子  
  330.                                         startI = i;  
  331.                                         startJ = j;  
  332.                                     }  
  333.                                 }  
  334.                             }  
  335.                             else{//之前选中过棋子  
  336.                                 if(qizi[i][j] != 0){//点击的位置有棋子  
  337.                                     if(qizi[i][j] > 7){//如果是自己的棋子.  
  338.                                         selectqizi = qizi[i][j];//将该棋子设为选中的棋子  
  339.                                         startI = i;  
  340.                                         startJ = j;  
  341.                                     }  
  342.                                     else{//如果是对方的棋子  
  343.                                         endI = i;  
  344.                                         endJ = j;//保存该点  
  345.                                         boolean canMove = guiZe.canMove(qizi, startI, startJ, endI, endJ);  
  346.                                         if(canMove){//如果可以移动过去  
  347.                                             caiPan = false;//不让玩家走了  
  348.                                             if(qizi[endI][endJ] == 1 || qizi[endI][endJ] == 8){//如果是“帅”或“将”  
  349.                                                 this.success();//胜利了   
  350.                                             }  
  351.                                             else{  
  352.                                                 if(activity.isSound){  
  353.                                                     go.start();//播放下棋声音  
  354.                                                 }  
  355.                                                 qizi[endI][endJ] = qizi[startI][startJ];//移动棋子  
  356.                                                 qizi[startI][startJ] = 0;//将原来处设空  
  357.                                                 startI = -1;  
  358.                                                 startJ = -1;  
  359.                                                 endI = -1;  
  360.                                                 endJ = -1;//还原保存点  
  361.                                                 focus = false;//标记当前没有选中棋子  
  362.                                                   
  363.                                                 ChessMove cm = guiZe.searchAGoodMove(qizi);//根据当前局势查询一个最好的走法  
  364.                                                 if(activity.isSound){  
  365.                                                     go.start();//播放下棋声音  
  366.                                                 }  
  367.                                                 qizi[cm.toX][cm.toY] = qizi[cm.fromX][cm.fromY];//移动棋子  
  368.                                                 qizi[cm.fromX][cm.fromY] = 0;  
  369.                                                 caiPan = true;//恢复玩家响应  
  370.                                             }  
  371.                                         }  
  372.                                     }  
  373.                                 }//end点击的位置有棋子  
  374.                                 else{//如果点击的位置没有棋子  
  375.                                     endI = i;  
  376.                                     endJ = j;                             
  377.                                     boolean canMove = guiZe.canMove(qizi, startI, startJ, endI, endJ);//查看是否可走  
  378.                                     if(canMove){//如果可以移动  
  379.                                         caiPan = false;//不让玩家走了  
  380.                                         if(activity.isSound){  
  381.                                             go.start();//播放下棋声音  
  382.                                         }  
  383.                                         qizi[endI][endJ] = qizi[startI][startJ];//移动棋子  
  384.                                         qizi[startI][startJ] = 0;//将原来处置空  
  385.                                         startI = -1;  
  386.                                         startJ = -1;  
  387.                                         endI = -1;  
  388.                                         endJ = -1;//还原保存点  
  389.                                         focus = false;//标志位设false  
  390.   
  391.                                         ChessMove cm = guiZe.searchAGoodMove(qizi);//得到一步走法   
  392.                                         if(qizi[cm.toX][cm.toY] == 8){//电脑吃了您的将  
  393.                                             status = 2;//切换游戏状态为失败  
  394.                                         }  
  395.                                         if(activity.isSound){//需要播放声音时  
  396.                                             go.start();//播放下棋声音  
  397.                                         }  
  398.                                         qizi[cm.toX][cm.toY] = qizi[cm.fromX][cm.fromY];//移动棋子  
  399.                                         qizi[cm.fromX][cm.fromY] = 0;  
  400.                                         caiPan = true;//恢复玩家响应  
  401.                                     }  
  402.                                 }  
  403.                             }//end 之前选中过棋子  
  404.                         }  
  405.                     }//end点击的位置在棋盘内时  
  406.             }//end游戏中时  
  407.         }  
  408.         return super.onTouchEvent(event);  
  409.     }  
  410.       
  411.     public int[] getPos(MotionEvent e){//将坐标换算成数组的维数  
  412.         int[] pos = new int[2];  
  413.         double x = e.getX();//得到点击位置的x坐标  
  414.         double y = e.getY();//得到点击位置的y坐标  
  415.         if(x>10 && y>10 && x<10+qiPan.getWidth() && y<10+qiPan.getHeight()){//点击的是棋盘时  
  416.             pos[0] = Math.round((float)((y-21)/36));//取得所在的行  
  417.             pos[1] = Math.round((float)((x-21)/35));//取得所在的列  
  418.         }  
  419.         else{//点击的位置不是棋盘时  
  420.             pos[0] = -1;//将位置设为不可用  
  421.             pos[1] = -1;  
  422.         }  
  423.         return pos;//将坐标数组返回  
  424.     }  
  425.       
  426.     public void success(){//胜利了  
  427.         status = 1;//切换到胜利状态  
  428.     }  
  429.   
  430.     public void surfaceChanged(SurfaceHolder holder, int format, int width,  
  431.             int height) {  
  432.     }  
  433.   
  434.     public void surfaceCreated(SurfaceHolder holder) {//重写的  
  435.         this.thread.setFlag(true);  
  436.         this.thread.start();//启动刷帧线程  
  437.         timeThread.setFlag(true);  
  438.         timeThread.start();//启动思考时间的线程  
  439.     }  
  440.   
  441.     public void surfaceDestroyed(SurfaceHolder holder) {//view被释放时调用的  
  442.         boolean retry = true;  
  443.         thread.setFlag(false);//停止刷帧线程  
  444.         timeThread.setFlag(false);//停止思考时间线程  
  445.         while (retry) {  
  446.             try {  
  447.                 thread.join();  
  448.                 timeThread.join();//等待线程结束  
  449.                 retry = false;//设置循环标志位为false  
  450.             }   
  451.             catch (InterruptedException e) {//不断地循环,直到等待的线程结束  
  452.             }  
  453.         }  
  454.     }  
  455.     class TutorialThread extends Thread{//刷帧线程  
  456.         private int span = 300;//睡眠的毫秒数   
  457.         private SurfaceHolder surfaceHolder;//SurfaceHolder的引用  
  458.         private GameView gameView;//gameView的引用  
  459.         private boolean flag = false;//循环标志位  
  460.         public TutorialThread(SurfaceHolder surfaceHolder, GameView gameView) {//构造器  
  461.             this.surfaceHolder = surfaceHolder;//得到SurfaceHolder引用  
  462.             this.gameView = gameView;//得到GameView的引用  
  463.         }  
  464.         public void setFlag(boolean flag) {//设置循环标记  
  465.             this.flag = flag;  
  466.         }  
  467.         public void run() {//重写的方法  
  468.             Canvas c;//画布  
  469.             while (this.flag) {//循环绘制  
  470.                 c = null;  
  471.                 try {  
  472.                     c = this.surfaceHolder.lockCanvas(null);  
  473.                     synchronized (this.surfaceHolder) {  
  474.                         gameView.onDraw(c);//调用绘制方法  
  475.                     }  
  476.                 } finally {//用finally保证下面代码一定被执行  
  477.                     if (c != null) {  
  478.                         //更新屏幕显示内容  
  479.                         this.surfaceHolder.unlockCanvasAndPost(c);  
  480.                     }  
  481.                 }  
  482.                 try{  
  483.                     Thread.sleep(span);//睡眠span毫秒  
  484.                 }catch(Exception e){//不会异常信息  
  485.                     e.printStackTrace();//打印异常堆栈信息  
  486.                 }  
  487.             }  
  488.         }  
  489.     }  
  490. }  



转载:http://blog.csdn.net/chaoyu168/article/details/51426882

目录
相关文章
|
3天前
|
Linux 编译器 Android开发
FFmpeg开发笔记(九)Linux交叉编译Android的x265库
在Linux环境下,本文指导如何交叉编译x265的so库以适应Android。首先,需安装cmake和下载android-ndk-r21e。接着,下载x265源码,修改crosscompile.cmake的编译器设置。配置x265源码,使用指定的NDK路径,并在配置界面修改相关选项。随后,修改编译规则,编译并安装x265,调整pc描述文件并更新PKG_CONFIG_PATH。最后,修改FFmpeg配置脚本启用x265支持,编译安装FFmpeg,将生成的so文件导入Android工程,调整gradle配置以确保顺利运行。
24 1
FFmpeg开发笔记(九)Linux交叉编译Android的x265库
|
26天前
|
Java Android开发
Android 开发获取通知栏权限时会出现两个应用图标
Android 开发获取通知栏权限时会出现两个应用图标
12 0
|
1月前
|
XML 缓存 Android开发
Android开发,使用kotlin学习多媒体功能(详细)
Android开发,使用kotlin学习多媒体功能(详细)
102 0
|
1月前
|
设计模式 人工智能 开发工具
安卓应用开发:构建未来移动体验
【2月更文挑战第17天】 随着智能手机的普及和移动互联网技术的不断进步,安卓应用开发已成为一个热门领域。本文将深入探讨安卓平台的应用开发流程、关键技术以及未来发展趋势。通过分析安卓系统的架构、开发工具和框架,本文旨在为开发者提供全面的技术指导,帮助他们构建高效、创新的移动应用,以满足不断变化的市场需求。
18 1
|
1月前
|
机器学习/深度学习 调度 Android开发
安卓应用开发:打造高效通知管理系统
【2月更文挑战第14天】 在移动操作系统中,通知管理是影响用户体验的关键因素之一。本文将探讨如何在安卓平台上构建一个高效的通知管理系统,包括服务、频道和通知的优化策略。我们将讨论最新的安卓开发工具和技术,以及如何通过这些工具提高通知的可见性和用户互动性,同时确保不会对用户造成干扰。
33 1
|
17天前
|
XML 开发工具 Android开发
构建高效的安卓应用:使用Jetpack Compose优化UI开发
【4月更文挑战第7天】 随着Android开发不断进化,开发者面临着提高应用性能与简化UI构建流程的双重挑战。本文将探讨如何使用Jetpack Compose这一现代UI工具包来优化安卓应用的开发流程,并提升用户界面的流畅性与一致性。通过介绍Jetpack Compose的核心概念、与传统方法的区别以及实际集成步骤,我们旨在提供一种高效且可靠的解决方案,以帮助开发者构建响应迅速且用户体验优良的安卓应用。
|
20天前
|
监控 算法 Android开发
安卓应用开发:打造高效启动流程
【4月更文挑战第5天】 在移动应用的世界中,用户的第一印象至关重要。特别是对于安卓应用而言,启动时间是用户体验的关键指标之一。本文将深入探讨如何优化安卓应用的启动流程,从而减少启动时间,提升用户满意度。我们将从分析应用启动流程的各个阶段入手,提出一系列实用的技术策略,包括代码层面的优化、资源加载的管理以及异步初始化等,帮助开发者构建快速响应的安卓应用。
|
20天前
|
Java Android开发
Android开发之使用OpenGL实现翻书动画
本文讲述了如何使用OpenGL实现更平滑、逼真的电子书翻页动画,以解决传统贝塞尔曲线方法存在的卡顿和阴影问题。作者分享了一个改造后的外国代码示例,提供了从前往后和从后往前的翻页效果动图。文章附带了`GlTurnActivity`的Java代码片段,展示如何加载和显示书籍图片。完整工程代码可在作者的GitHub找到:https://github.com/aqi00/note/tree/master/ExmOpenGL。
21 1
Android开发之使用OpenGL实现翻书动画
|
20天前
|
Android开发 开发者
Android开发之OpenGL的画笔工具GL10
这篇文章简述了OpenGL通过GL10进行三维图形绘制,强调颜色取值范围为0.0到1.0,背景和画笔颜色设置方法;介绍了三维坐标系及与之相关的旋转、平移和缩放操作;最后探讨了坐标矩阵变换,包括设置绘图区域、调整镜头参数和改变观测方位。示例代码展示了如何使用这些方法创建简单的三维立方体。
15 1
Android开发之OpenGL的画笔工具GL10
|
26天前
|
Android开发
Android开发小技巧:怎样在 textview 前面加上一个小图标。
Android开发小技巧:怎样在 textview 前面加上一个小图标。
12 0