android俄罗斯方块完整代码

这段时间一直没有更新自己的博客，很多东西不经常看看会生疏了许多。在这里我就把自己前段时间编写的android俄罗斯方块代码贴出来。

转载请注明出处~~~~~~~~~~~~~~~~谢谢！

http://blog.csdn.net/wu10045125/article/details/8248356

再贴出几张图片:

整个游戏我分为10个java文件：

先是俄罗斯方块的形状存储statefang.java，代码如下：

package com.example.eluosifangkuai;

public class statefang { //方块的逻辑类

public static int [][][] state = new int[][][] {
  {// I
   { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 } }, {// I1
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 1 } }, {// I2
   { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 } }, {// I3
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 1 } }, {// I4
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 } }, {// O5
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 } }, {// O6
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 } }, {// O7
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 1, 0 } }, {// O8
   { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 0 } }, {// L9
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 1, 0, 0, 0 } }, {// L10
   { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 } }, {// L11
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 1, 1, 1, 0 } }, {// L12
   { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 0, 0, 1, 0 }, { 0, 1, 1, 0 } }, {// J13
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 0, 0, 0 }, { 1, 1, 1, 0 } }, {// J14
   { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 }, { 0, 1, 0, 0 } }, {// J15
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 0, 1, 0 } }, {// J16
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 1, 1, 1, 0 } }, {// T17
   { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 0, 1, 1, 0 }, { 0, 0, 1, 0 } }, {// T18
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 1, 0 }, { 0, 1, 0, 0 } }, {// T19
   { 0, 0, 0, 0 }, { 1, 0, 0, 0 }, { 1, 1, 0, 0 }, { 1, 0, 0, 0 } }, {// T20
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 1, 1, 0, 0 } }, {// S21
   { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 0, 1, 0 } }, {// S22
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 0, 1, 1, 0 }, { 1, 1, 0, 0 } }, {// S23
   { 0, 0, 0, 0 }, { 0, 1, 0, 0 }, { 0, 1, 1, 0 }, { 0, 0, 1, 0 } }, {// Z24
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 1, 0 } }, {// Z25
   { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 } }, {// Z26
   { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, { 1, 1, 0, 0 }, { 0, 1, 1, 0 } }, {// Z27
   { 0, 0, 0, 0 }, { 0, 0, 1, 0 }, { 0, 1, 1, 0 }, { 0, 1, 0, 0 } } // 28

};

}

我们当然还要编写音乐播放类，资源播放类了等等。。。。。。

我把所有的图片资源编写在一个类里面，叫做GameResources.java，具体代码如下：

package com.example.eluosifangkuai;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Bitmap.Config;
import android.graphics.Paint;
import android.graphics.drawable.Drawable;

public class GameResources {

Resources m_Resources; // 资源类
Canvas m_Canvas;    // 画布
Bitmap m_Bitmaphc = null; // 缓冲位图
Bitmap m_Bitmap01 = null; // 图像位图
Bitmap [] m_Bitmaps = new Bitmap[8]; //精灵位图
Bitmap score; // 分数位图
Bitmap Play;   // 开始位图
Bitmap Level;
public GameResources(Context context) // 初始化装载位图
{
  m_Resources = context.getResources();
for(int i=0;i<7;i++)
{
  m_Bitmaps[i] = createImage(m_Resources.getDrawable(R.drawable.cube_960_011+i),18,18);
}
m_Bitmap01 = createImage(m_Resources.getDrawable(R.drawable.bgcatcher),320,480);
m_Bitmaps[7] = createImage(m_Resources.getDrawable(R.drawable.main11),320,402);

score = createImage(m_Resources.getDrawable(R.drawable.score),87,150);
Play = createImage(m_Resources.getDrawable(R.drawable.b7),320,480);
Level = createImage(m_Resources.getDrawable(R.drawable.levelup),139,88);
m_Bitmaphc = Bitmap.createBitmap(320,480, Config.ARGB_8888);
m_Canvas = new Canvas(m_Bitmaphc);
bitmapB();
}

public void bitmapB()
{
  Paint m_Paint = new Paint();
  m_Paint.setAntiAlias(true);
  m_Paint.setAlpha(220);
  m_Canvas.drawBitmap(m_Bitmap01, 0,0,null);
}
public static Bitmap createImage(Drawable tile, int w, int h) { // 双缓冲加载位图资源
  Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);
  Canvas canvas = new Canvas(bitmap);
  tile.setBounds(0, 0, w, h);
  tile.draw(canvas);
  return bitmap;
}

}

音乐播放类，MusicPlay.java 具体代码如下：

package com.example.eluosifangkuai;

import java.util.HashMap;
import java.util.Map;
import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.SoundPool;

public class MusicPlay {

public static MediaPlayer m_MediaPlay ; // 背景播放器
public static MediaPlayer m_MenuPlay ;
public static SoundPool soundPool;//声明音效播放器
public MediaPlayer m_FastDown ;

private static boolean musicSwitch = true;//音乐开关
private static boolean soundSwitch = true;//音效开关
private static Map soundMap; //音效资源id与加载过后的音源id的映射关系表
private static Context context;

public static void inItMusicPlay(Context c){
   context = c;
  }
public static void inItMenuMusicPlay(Context c){
   context = c;
  }
  //初始化背景播放器
public static void BgMediaplayer()
{
   m_MediaPlay = MediaPlayer.create(context, R.raw.gamebg);
   m_MediaPlay.setLooping(true);
}
public static void menuMusic()
{
  m_MenuPlay = MediaPlayer.create(context, R.raw.menubg);
  m_MenuPlay.setLooping(true);
}
    public static void pauseMusic()
    {
   if(m_MediaPlay.isPlaying())
   {
    m_MediaPlay.pause();
   }
}
    public static void pauseMenuMusic()
    {
   if(m_MenuPlay.isPlaying())
   {
    m_MenuPlay.pause();
   }
}
    public static void startMusic(){
  if(musicSwitch){
   m_MediaPlay.start();
  }
}
    public static void startMenuMusic(){
  if(musicSwitch){
   m_MenuPlay.start();
  }
}
    public static void releaseMusic(){
  if(m_MediaPlay != null){
   m_MediaPlay.release();
  }
}
    public static void releaseMenuMusic(){
  if(m_MenuPlay != null)
  {
   m_MenuPlay.release();
  }
}

//设置音乐开关
public static void setMusicSwitch(boolean musicSwitch){
  MusicPlay.musicSwitch = musicSwitch;
  if(MusicPlay.musicSwitch){
   m_MediaPlay.start();
  }
  else{
   m_MediaPlay.stop();
  }
}
public static void inItSound()
{
  soundPool = new SoundPool(8,AudioManager.STREAM_MUSIC,0);
  soundMap = new HashMap();
  //将音效资源加入 soundPool，并做成soundMap 映射
  soundMap.put(R.raw.action,soundPool.load(context, R.raw.action, 1));
  soundMap.put(R.raw.fastdown,soundPool.load(context, R.raw.fastdown, 1));
  soundMap.put(R.raw.rotation,soundPool.load(context, R.raw.rotation, 1));
  soundMap.put(R.raw.down,soundPool.load(context, R.raw.down, 1));
  soundMap.put(R.raw.delete1,soundPool.load(context, R.raw.delete1, 1));
  soundMap.put(R.raw.delete2,soundPool.load(context, R.raw.delete2, 1));
  soundMap.put(R.raw.delete3,soundPool.load(context, R.raw.delete3, 1));
  soundMap.put(R.raw.delete4,soundPool.load(context, R.raw.delete4, 1));
}
      public static int playSound(int resId,int loop)
      {

  if(!soundSwitch){
   return 0;
  }

  Integer soundId = soundMap.get(resId);
        if(soundId != null)
        {
        return soundPool.play(soundId, 1, 1, 1, loop, 1);
        }
        else
        {
        return 0;
        }
     }
      public static void releaseSound(){
   if(soundPool != null){
    soundPool.release();
   }
  }
}

另外我还编写了一个图片按钮类，名为ImageButton.java 具体代码如下：

package com.example.eluosifangkuai;

import java.io.InputStream;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;

public class ImageButton {

     // 按钮图片
     private Bitmap mBitButton = null;

     //图片绘制的XY坐标
     private int mPosX =0;
     private int mPosY =0;
     //图片绘制的宽高
     private int mWidth =0;
     private int mHeight =0;

     public ImageButton(Context context, int frameBitmapID, int x, int y) {
  mBitButton = ReadBitMap(context,frameBitmapID);
  mPosX = x;
  mPosY = y;
  mWidth = mBitButton.getWidth();
  mHeight = mBitButton.getHeight();
     }

     //绘制图片按钮
     public void DrawImageButton(Canvas canvas, Paint paint) {
  canvas.drawBitmap(mBitButton, mPosX, mPosY, paint);
     }


    // 判断是否点中图片按钮
     public boolean IsClick(int x, int y) {
  boolean isClick = false;
  if (x >= mPosX && x <= mPosX + mWidth && y >= mPosY
   && y <= mPosY + mHeight) {
      isClick = true;
  }
  return isClick;
     }


      // 读取图片资源

     public Bitmap ReadBitMap(Context context, int resId) {
  BitmapFactory.Options opt = new BitmapFactory.Options();
  opt.inPreferredConfig = Bitmap.Config.RGB_565;
  opt.inPurgeable = true;
  opt.inInputShareable = true;

  // 获取资源图片

  InputStream is = context.getResources().openRawResource(resId);
  return BitmapFactory.decodeStream(is, null, opt);

     }

}

下面是显示开始图片按钮MenuView.java，代码如下：

package com.example.eluosifangkuai;

import android.content.Context;
import android.graphics.Canvas;
import android.view.View;

public class MenuView extends View{

    ImageButton m_ImageButton_Play; // 开始播放按钮
    ImageButton m_ImageButton_Play_a;
    ImageButton m_bg;   // 背景图片
public MenuView(Context context) { // 初始化工作
  super(context);
  m_bg = new ImageButton(context,R.drawable.b7,0,0);
  m_ImageButton_Play = new ImageButton(context,R.drawable.play,62,136);
  m_ImageButton_Play_a = new ImageButton(context,R.drawable.play1,62,136);
}

    public void onDraw(Canvas canvas) // 画布中显示位图
    {
    m_bg.DrawImageButton(canvas, null);
    m_ImageButton_Play.DrawImageButton(canvas, null);

    }
}

还有一个启动活动类，MainActivity.java 代码为：

package com.example.eluosifangkuai;

import android.os.Bundle;
import android.os.Handler;
import android.app.Activity;
import android.content.Intent;
import android.util.Log;
import android.view.Window;
import android.view.WindowManager;
public class MainActivity extends Activity {

    private static final int GOTO_MAIN_ACTIVITY = 0; // 发送消息参数
    private Handler mHandler = new Handler(){   // 消息推送类
        public void handleMessage(android.os.Message msg) {

            switch (msg.what) {
                case GOTO_MAIN_ACTIVITY:
                Log.i("yunxing","OK2222");
                    Intent intent = new Intent();
                    intent.setClass(MainActivity.this, WelcomeActivity.class); // 活动跳转
                    startActivity(intent);
                    Log.i("yunxing","ERROR");
                   finish();
                    break;

                default:
                    break;
            }
        };
    };
public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE); //设置窗口无标题和全屏
         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
         Log.i("yunxing","OK");
         setContentView(R.layout.activity_main);
         mHandler.sendEmptyMessageDelayed(GOTO_MAIN_ACTIVITY, 5000);//5秒跳转
         Log.i("yunxing","OK111");
     }

}

转向活动类，WelcomeActivity.java 代码为：

package com.example.eluosifangkuai;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;

import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.view.GestureDetector;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.view.GestureDetector.OnGestureListener;
import android.view.View.OnTouchListener;
import android.widget.TextView;

public class WelcomeActivity extends Activity implements OnTouchListener,OnGestureListener{

GestureDetector m_GestureDetector ; // 手势

public WelcomeActivity()
{
  m_GestureDetector = new GestureDetector((OnGestureListener) this);
}
    TextView mTextView = null;
    MenuView m_MenuView = null;

     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         requestWindowFeature(Window.FEATURE_NO_TITLE); // 设置无标题，全面模式
         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
         m_MenuView = new MenuView(this);
         setContentView(m_MenuView);
         MusicPlay.inItMenuMusicPlay(this);
         MusicPlay.menuMusic();
         MusicPlay.startMenuMusic();
         m_MenuView.setOnTouchListener((OnTouchListener) this);
      m_MenuView.setClickable(true);
      m_GestureDetector.setIsLongpressEnabled(true);
     }


     public boolean onKeyDown(int key,KeyEvent keyevent)     //对按键的响应
   {
     if(key == KeyEvent.KEYCODE_BACK && keyevent.getRepeatCount() == 0) //返回键提示对话框
     {
      dialog();
      return true;
     }
     return true;//super.onKeyDown(key, keyevent);
   }

     protected void dialog() // 对话框函数
   {
           AlertDialog.Builder builder = new Builder(WelcomeActivity.this);
           builder.setMessage("是否需要帮助！！！");
           builder.setTitle("提示");
           builder.setPositiveButton("取消",
           new android.content.DialogInterface.OnClickListener() {
               public void onClick(DialogInterface dialog, int which) {
                MusicPlay.releaseMenuMusic();
                   dialog.dismiss();
                   android.os.Process.killProcess(android.os.Process.myPid());
               }
           });
           builder.setNegativeButton("确定",
           new android.content.DialogInterface.OnClickListener() {
               public void onClick(DialogInterface dialog, int which) {
                   Intent intent = new Intent(WelcomeActivity.this,helpActivity.class);
            startActivity(intent);
               }
           });
           builder.create().show();
       }

     public boolean onTouch(View v, MotionEvent event)
        {
         return m_GestureDetector.onTouchEvent(event);
        }

     public void onResume()
     {
     super.onResume();
     MusicPlay.startMenuMusic();
     }

     public void onDestroy()
     {
     super.onDestroy();
     MusicPlay.releaseMenuMusic();
     WelcomeActivity.this.finish();
     }

  public boolean onDown(MotionEvent event) {
   // TODO Auto-generated method stub
   int x = (int)event.getX();
   int y = (int)event.getY();
   if(m_MenuView.m_ImageButton_Play.IsClick(x, y))
   {
    Intent intent = new Intent(WelcomeActivity.this,GameActivity.class);
       startActivity(intent);
       MusicPlay.pauseMenuMusic();
   }

   return true;
  }
  public boolean onFling(MotionEvent arg0, MotionEvent arg1, float arg2,
    float arg3) {
   // TODO Auto-generated method stub
   return false;
  }
  public void onLongPress(MotionEvent arg0) {
   // TODO Auto-generated method stub

  }
  public boolean onScroll(MotionEvent arg0, MotionEvent arg1, float arg2,
    float arg3) {
   // TODO Auto-generated method stub
   return false;
  }
  public void onShowPress(MotionEvent arg0) {
   // TODO Auto-generated method stub

  }
  public boolean onSingleTapUp(MotionEvent arg0) {
   // TODO Auto-generated method stub
   return false;
  }


}

帮助类，helpActivity.java 代码为：

package com.example.eluosifangkuai;

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

public class helpActivity extends Activity{

public void onCreate(Bundle help)
{
  super.onCreate(help);
   requestWindowFeature(Window.FEATURE_NO_TITLE); // 设置无标题，全面模式
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
  setContentView(R.layout.help);
}
}

接下来就游戏的核心类了，所有游戏运行都在这两个类中，首先是一个游戏视图类，包括了游戏运行的核心代码。在以后我会慢慢解释这些代码的含义，希望大家支持。

GameView.java 具体代码为：

package com.example.eluosifangkuai;

import java.util.Random;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;

public class GameView extends View{

public final static int of_Width = 24;   // 游戏运行的长度
public final static int of_Height = 10; // 游戏运行的宽度
int gradeCourt = 0;     // 分数、等级、消行数
int levl = 1;
int line = 0;
private int[][] m_screen = new int[of_Width][of_Height]; //屏幕数组
private int[][] m_color = new int[of_Width][of_Height];   // 颜色方块数组
private int[] log_color = new int[of_Height];         // 消行数时记录颜色值
private int k = 0,a = 0,state = 0,statenext = 0;     // 随即数和随即方块
private int of_x = 0,of_y = 0;        // 下落位置
private int of_x_x = 0;          // 阴影离下方物的距离
private int add_dis_y = 0;      // 震动距离
public int log_X = 0;   // 升级位图绘制标志
public int timeTask = 1000; // 等级级数相关参数
private boolean buttonLeft = false;     //按键变换颜色值
private boolean buttonRight = false;
public boolean buttonRotate = false;
public boolean buttonDown = false;
public boolean buttonFastDown = false;
public boolean buttonPause = false;
ImageButton m_ButtonLeft = null;   //图像按钮
ImageButton m_ButtonLeft_a = null;
ImageButton m_ButtonRight = null;
ImageButton m_ButtonRight_a = null;
ImageButton m_ButtonDown = null;
ImageButton m_ButtonDown_a = null;
ImageButton m_ButtonFastDown = null;
ImageButton m_ButtonFastDown_a = null;
ImageButton m_ButtonRotate = null;
ImageButton m_ButtonRotate_a = null;
ImageButton m_ButtonPause = null;
ImageButton m_ButtonPause_a = null;
Canvas m_Canvas = null;
GameResources m_GameResources;
Random m_Random = null;

public GameView(Context context) // 视图类构造函数负责一些变量的初始化
{
  super(context);
  m_GameResources = new GameResources(context);   // 初始化位图资源变量
  inItButton(context);        // 初始化图像按钮
  clean();        // 清除游戏开始方块数组值
  m_Random = new Random();     // 产生随即值函数
  state = Math.abs(m_Random.nextInt()%7);     //当前方块颜色值
  statenext = Math.abs(m_Random.nextInt()%7); //下一个方块颜色值
  k = Math.abs(m_Random.nextInt()%28);    // 当前方块
  a = Math.abs(m_Random.nextInt()%28);   // 下一个方块
  for(int i=0;i<4;i++)           // 初始化方块
  {
   for(int j=0;j<4;j++)
   {
    if(0 != statefang.state[k][i][j])
    {
     m_screen[i][j+3] = statefang.state[k][i][j];
     m_color[i][j+3] = state;
    }
   }
  }
  of_y = 3;    // 出现方块的位置值
  fastDown(1);      // 获取下方透明方块的距离
  setFocusable(true);      // 获取按键焦点，可以响应触摸事件
  setFocusableInTouchMode(true);
}

public void inItButton(Context context)     // 初始化图像按钮
{
  m_ButtonLeft = new ImageButton(context,R.drawable.control_left1,0,354);
  m_ButtonLeft_a = new ImageButton(context,R.drawable.control_left2,0,354);
  m_ButtonRight = new ImageButton(context,R.drawable.control_right1,80,354);
  m_ButtonRight_a = new ImageButton(context,R.drawable.control_right2,80,354);
  m_ButtonRotate = new ImageButton(context,R.drawable.control_rotate1,160,354);
  m_ButtonRotate_a = new ImageButton(context,R.drawable.control_rotate2,160,354);
  m_ButtonDown = new ImageButton(context,R.drawable.control_down1,240,354);
  m_ButtonDown_a = new ImageButton(context,R.drawable.control_down2,240,354);
  m_ButtonFastDown = new ImageButton(context,R.drawable.control_drop1,230,300);
  m_ButtonFastDown_a = new ImageButton(context,R.drawable.control_drop2,230,300);
}
public void clean()
{
  for(int i = 0;i   {
   for(int j=0;j    {
    m_screen[i][j] = 0;
    m_color[i][j] = -1;
   }
  }
}
public void onDraw(Canvas canvas)   // 画图函数，主线程中实现不停刷新此函数响应刷新
{
  super.onDraw(canvas);
  Paint m_Paint = new Paint();       // 新建画笔
  m_Paint.setAntiAlias(true);   // 设置抗锯齿
  m_Paint.setFakeBoldText(true); //true为粗体，false为非粗体
  m_Paint.setColor(Color.RED);
  m_Paint.setAlpha(100);   // 设置透明度
  this.setKeepScreenOn(true);   // 保存屏幕常亮
  Log.i("onDraw","执行了");
  canvas.drawBitmap(m_GameResources.m_Bitmaphc,0,0,null);    // 画出双缓冲中的图片
  canvas.drawBitmap(m_GameResources.m_Bitmaps[7],0,add_dis_y,null);
  canvas.drawBitmap(m_GameResources.score,230,150+add_dis_y,null);


  PaintTm(canvas,m_Paint);   // 绘制下方透明方块
  Paintnext(canvas);       // 绘制下一个产生方块
  paintCourt(canvas);     // 绘制方块本身，在屏幕数组的位置
  PaintButton(canvas,m_Paint); // 绘制下方方向导航按键
  canvas.drawText(" "+levl,256,185+add_dis_y,m_Paint);   // 绘制等级、分数、消行数
  canvas.drawText(" "+gradeCourt,255,185+add_dis_y+50,m_Paint);
  canvas.drawText(" "+line,255,185+add_dis_y+100,m_Paint);
  add_dis_y = 0;    // 调整震动原始值
  m_Canvas = canvas;
}
public void PaintButton(Canvas canvas,Paint m_Paint)// 绘制下方方向导航按键和升级位图
{
  if(timeTask == 800 || timeTask == 500 || timeTask == 200)
  {
   if(log_X == 0)
      {
    canvas.drawBitmap(m_GameResources.Level,35,200, m_Paint);
    log_X = 1;
      }
  }
  if(buttonLeft)
  {
   m_ButtonLeft_a.DrawImageButton(m_Canvas, m_Paint);
  }
  else
  {
   m_ButtonLeft.DrawImageButton(canvas, m_Paint);
  }

  buttonLeft = false;

  if(buttonRight)
  {
   m_ButtonRight_a.DrawImageButton(canvas, m_Paint);
  }
  else
  {
   m_ButtonRight.DrawImageButton(canvas, m_Paint);
  }

  buttonRight = false;

  if(buttonRotate)
  {
   m_ButtonRotate_a.DrawImageButton(canvas, m_Paint);
  }
  else
  {
   m_ButtonRotate.DrawImageButton(canvas, m_Paint);
  }

  buttonRotate = false;

  if(buttonDown)
  {
   m_ButtonDown_a.DrawImageButton(canvas, m_Paint);
  }
  else
  {
   m_ButtonDown.DrawImageButton(canvas, m_Paint);
  }

  buttonDown = false;

  if(buttonFastDown)
  {
   m_ButtonFastDown_a.DrawImageButton(canvas, m_Paint);
  }
  else
  {
   m_ButtonFastDown.DrawImageButton(canvas, m_Paint);
  }

  buttonFastDown = false;

}
public void paintCourt(Canvas canvas)
{
  for(int i=0;i   {
   for(int j=0;j    {
    if(0 != m_screen[i][j] && i > 3)
    {
     canvas.drawBitmap(m_GameResources.m_Bitmaps[m_color[i][j]],j*18+17,(i-4)*18+11+add_dis_y,null);
    }
   }
  }
}

public void colorstate(int x,int y,int stateColor)   // 颜色的状态值
{
  for(int i=0;i<4;i++)
  {
   for(int j=0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
    m_color[x+i][y+j] = stateColor;
   }
  }
}
public void PaintTm(Canvas canvas,Paint paint) // 绘制下方半透明方块
{
  for(int i=0;i<4;i++)
  {
   for(int j=0;j<4;j++)
   {
    int num = ((of_x_x-4+i)*18+11+add_dis_y);

    if(0 != statefang.state[k][i][j] && num >= 11)
    {
     canvas.drawBitmap(m_GameResources.m_Bitmaps[state],(of_y+1+j)*18,(of_x_x-4+i)*18+11+add_dis_y,paint);

    }
   }
  }
}
    public void Paintnext(Canvas canvas)
    {
    for(int i=0;i<4;i++)
  {
   for(int j=0;j<4;j++)
   {
    if(0 != statefang.state[a][i][j])
    {
     canvas.drawBitmap(m_GameResources.m_Bitmaps[statenext],j*15+225,60+i*15+add_dis_y,null);
    }
   }
  }
}

public void idKeyDown(int key,KeyEvent keyevent)     //对按键的响应
{
  if(key == KeyEvent.KEYCODE_DPAD_DOWN && moveDownOn())//&& of_x < of_Width-4){
  {
   Down();
   fastDown(1);
   buttonDown = false;
  }
  if(key == KeyEvent.KEYCODE_DPAD_RIGHT && moveRightOn())
  {
      Right();
      fastDown(1);
      buttonRight = false;
     }
  if(key == KeyEvent.KEYCODE_DPAD_LEFT && moveLeftOn() )//&& of_y > 0)
  {
   Left();
   fastDown(1);
   buttonLeft = false;
  }
  if(key == KeyEvent.KEYCODE_DPAD_UP&&rotateOnCourt())
  {
   rate();
   fastDown(1);
   buttonRotate = false;
  }
  if(key == KeyEvent.KEYCODE_DPAD_CENTER && moveDownOn())
  {
   FastDown();
   fastDown(1);
   buttonFastDown = false;
  }

}

public boolean availableForTile(int[][] tile,int x,int y) //方块旋转判断
{
  for (int i = 0; i < 4; i++) {
   for (int j = 0; j < 4; j++) {
    if (tile[i][j] != 0) {
     if (!isSpace(x + i, y + j)) {
      return false;
     }
    }
   }
  }
  return true;
}
public boolean rotateOnCourt() {   // 是否能够旋转，能返回true，方块按向右旋转
  int tempX = 0, tempY = 0;
  int tempShape;
  int[][] tempTile = new int[4][4];

  tempShape = k;
  if (tempShape % 4 > 0) {
   tempShape--;
  } else {
   tempShape += 3;
  }
  for (int i = 0; i < 4; i++) {
   for (int j = 0; j < 4; j++) {
    tempTile[i][j] = statefang.state[tempShape][i][j];
   }
  }

  tempX = of_x;
  tempY = of_y;
  boolean canTurn = false;
  cleanstate(of_x,of_y);
  if( availableForTile(tempTile,tempX,tempY) )
  {
   canTurn = true;
  }
  else if(availableForTile(tempTile,tempX-1,tempY) )
  {
   canTurn = true;
   tempX--;
  }
  else if(availableForTile(tempTile,tempX-2,tempY) )
  {
   canTurn =true;
   tempX -=2;
  }
  else if(availableForTile(tempTile,tempX+1,tempY) )
  {
   canTurn = true;
   tempX++;
  }
  else if(availableForTile(tempTile,tempX+2,tempY) )
  {
   canTurn = true;
   tempX += 2;
  }

  if (canTurn) {
   k = tempShape;
   of_x = tempX;
   of_y = tempY;
   return true;
  }
  for(int i=0;i<4;i++) // 执行旋转之前屏幕数组和颜色数组回到当前值
  {
   for(int j=0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
    {
     m_screen[of_x+i][of_y+j] = 1;
     m_color[of_x+i][of_y+j] = state;
    }
   }
  }
  return false;
}

public boolean isSpace(int x,int y) // 判断x、y 这个方块是否在超越边界以及是否为原始值0
{
  if(x< 0 || x>=of_Width)
   return false;
  if(y<0 || y>=of_Height)
   return false;
  if(m_screen[x][y] == 0)
   return true;
  return false;
}
public boolean moveDownOn()    // 判断能否继续下落
{
  int n = 0;
  for(int i=0;i<4;i++)
  {
   for(int j =0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
     {
      n = i;
     while(n<3 && statefang.state[k][n+1][j] != 0)
      n++;
     if(!isSpace(of_x+n+1,of_y+j))
      return false;
     }
   }
  }

  return true;
}

public int cleanFullLine()   // 清楚满行的行
{
  int num = 0,n=0,linenum = 0;
  num = brigeLine();
  for(int i = of_x+3;i>=of_x-1;i--)
  {
   if(fullLine(i))
   {
    n = i;
    for(int r=0;r     {
     log_color[r] = m_color[n][r];
    }

    linenum++;
    for(int j = n;j>=num;j--)
    {
     for(int k=0;k      {
      if(j == num)
       {
       m_screen[j][k] = 0;
       m_color[j][k] = -1;
       }
      else
      {
       m_screen[j][k] = m_screen[j-1][k];
       m_color[j][k] = m_color[j-1][k];
      }

     }
    }
    for(int t=0;t     {
     m_Canvas.drawBitmap(m_GameResources.m_Bitmaps[log_color[t]],24+t*18,(n-4)*18+25,null);
    }
    MusicPlay.playSound(R.raw.delete1+linenum,0);

    i = n+1;
   }
  }

  return linenum;
}

public int brigeLine()    //找出哪行没有方块并返回行值   否则返回0
{
  for(int i = of_x+3;i>0;i--)
  {
   int j = 0;
   while(j     j++;
   if(j == of_Height)
    return i+1;

  }
  return 0;
}
public boolean fullLine(int hang)   // 判断改行是否是满行
{
   int j = 0;
   while(j     j++;
   if(j == of_Height)
    return true;

  return false;
}

public void move() // 移动时，必须对屏幕数组和颜色数组校正
{
  for(int i=0;i<4;i++)
  {
   for(int j=0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
    {
     m_screen[i+of_x][j+of_y] = 1;
     m_color[i+of_x][j+of_y] = state;
    }
   }
  }
}

public boolean moveRightOn() // 能否右移动
{
  buttonRight = true;
  for(int i=0;i<4;i++)
  {
   for(int j =0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
     {
     while(j<3 && statefang.state[k][i][j+1] != 0)
      j++;
     if(!isSpace(of_x+i,of_y+j+1))
      return false;
     }
   }
  }
  return true;
}
public boolean moveLeftOn() // 能否左移动
{
  buttonLeft = true;

  for(int i=0;i<4;i++)
  {
   for(int j=0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
     {
        if(!isSpace(of_x+i,of_y+j-1))
          return false;
        else
          break;
     }
   }
  }
  return true;
}
public int fastDown(int log)   //能否快速下落，此函数有两种状态一种是返回阴影的值另一种是下落所学值
{
  int a[] = {100,100,100,100};
  int n=0,s = 0,m = 0;
  for(int i=0;i<4;i++)
  {
   for(int j =0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
     {
     m = i;
     while(m<3 && statefang.state[k][m+1][j] != 0)
      m++;
     if(isSpace(of_x+m+1,of_y+j))
     {
      n = 1;
      while(isSpace(of_x+m+(++n),of_y+j));
         a[s++] = n-1;
       }
     }
   }
  }
  switch(log) // 一个是下方透明方块的距离值，一个是实际下落方块的距离
  {
  case 1:of_x_x = of_x+min(min(a[0],a[1]),min(a[2],a[3]));return of_x_x;
  case 2:s = of_x;
  of_x += min(min(a[0],a[1]),min(a[2],a[3]));break;
  }

     return s;
}
public int min(int a,int b)
{
  if(a>=b)
   return b;
  else
   return a;
}
public void cleanstate(int x,int y)   // 清楚函数状态
{
  for(int i=0;i<4;i++)
  {
   for(int j=0;j<4;j++)
   {
    if(statefang.state[k][i][j] != 0)
    {
     m_screen[x+i][y+j] = 0;
     m_color[x+i][y+j] = -1;
    }
   }
  }
}

public void Court(int grade)       // 计分
{
  line += grade;
  switch(grade)
  {
  case 1:gradeCourt+=100;break;
  case 2:gradeCourt+=300;break;
  case 3:gradeCourt+=500;break;
  case 4:gradeCourt+=800;break;
  }
}
public boolean GameOver()   // 游戏结束
{
  for(int i=0;i   {
   if(m_screen[4][i] != 0)
    return true;
  }
  return false;
}
   public void Right()       // 右移函数
   {
    cleanstate(of_x,of_y);
  of_y++;
     move();
   }
   public void Left()      // 左移函数
   {
    cleanstate(of_x,of_y);
    of_y--;
  move();
   }
   public void Down()      // 下落函数
   {
    cleanstate(of_x,of_y);
  of_x++;
  move();
   }
   public void FastDown() // 快速下落函数
   {
    add_dis_y = 5;
   cleanstate(fastDown(2),of_y);
  move();
   }
   public void rate()    // 旋转函数
   {
    cleanstate(of_x,of_y);
  move();
   }
   public void NotDown()   // 方块下落到地步对屏幕数组进行一系列的处理
   {
      of_x_x = 0;
      colorstate(of_x, of_y,state);      // 保存颜色值
   Court(cleanFullLine());   // 消行计分
   }
   public void newState()
   {
      k = a;       // 交换方块值
   state = statenext; //交换颜色值
   a = Math.abs(m_Random.nextInt()%28); // 产生方块值
   statenext = Math.abs(m_Random.nextInt()%7); // 产生颜色值
   of_y = 3; // 重置下落位置
   of_x = 0;
   }
}

游戏视图类有了，当然需要一个活动去执行它了，定义了一个GameActivity.java 具体代码为：

package com.example.eluosifangkuai;

import android.app.Activity;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Service;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Vibrator;
import android.util.Log;
import android.view.GestureDetector;
import android.view.GestureDetector.OnGestureListener;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.Window;
import android.view.WindowManager;

public class GameActivity extends Activity implements OnTouchListener,OnGestureListener { // 实现手势，触摸监听

GestureDetector m_GestureDetector ; // 定义手势

public GameActivity() //构造函数完成手势的相关初始化
{
  m_GestureDetector = new GestureDetector((OnGestureListener) this);
}

protected static final int ii = 0x101;    // UI主线程发送消息匹配代码
protected static final int kk = 0x110;
private int dialog_xx = 0;
private boolean Thread_Log = true;       // 线程运行标志，用来暂停游戏
private float log = 0;         // 左滑时获取距离存放变量
private int log_num = 0;       // 下落在自由下落和快速下滑是声音选择变量
private int log_log = 0;
public int m_time_a,i=0;    // 下落时间变量，和运行次数的相关参数

Vibrator vibrator;   // 震动类声明
long[] pattern = {0,10,10,30}; //根据指定的模式进行震动                   //第一个参数：该数组中第一个元素是等待多长的时间才启动震动，                    //之后将会是开启和关闭震动的持续时间，单位为毫秒                    //第二个参数：重复震动时在pattern中的索引，如果设置为-1则表示不重复震动

GameView m_GameView = null;   // 定义视图类变量

    Handler m_Handler = new Handler()   // 定义Handler变量实现更新View视图
    {
    public void handleMessage(Message msg)
    {
      switch(msg.what)
      {
      case GameActivity.kk:
       Thread_Log = false;
        dialog_a();
    break ;
          case GameActivity.ii:
                           m_GameView.invalidate();
      }
      super.handleMessage(msg);
    }
    };

     public void onCreate(Bundle saved)
     {
    super.onCreate(saved);
    requestWindowFeature(Window.FEATURE_NO_TITLE);   // 设置无标题的全屏模式
    getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,WindowManager.LayoutParams.FLAG_FULLSCREEN);
    m_GameView = new GameView(this);   // 实例化GameView对象
    init();      // 初始化工作，包括声音
    new Thread(new GameThread()).start();   // 新建游戏线程
     }

private void init() // 初始化
{
   setContentView(m_GameView);    // 活动绘制GameView的内容
   vibrator = (Vibrator) getSystemService(Service.VIBRATOR_SERVICE);    // 获取系统服务震动
         m_GameView.setOnTouchListener((OnTouchListener) this);   // 设置可以响应触摸事件
         m_GameView.setClickable(true);
         m_GestureDetector.setIsLongpressEnabled(true); // 可以响应长按
         MusicPlay.inItMusicPlay(this); // 初始化播放器及相关操作
         MusicPlay.inItSound();
    MusicPlay.BgMediaplayer();
    MusicPlay.startMusic();
   Log.i("aiai", "run begin 111");
}

    class GameThread implements Runnable{

        public void run()
        {
          while(!Thread.currentThread().isInterrupted())
          {
           while(Thread_Log)   // 游戏是否暂停标志
           {
                 Message message = new Message(); // 新建消息函数
                 if(dialog_xx == 0)
                     message.what = GameActivity.ii; // 赋值消息
                 else
                  message.what = GameActivity.kk; // 赋值消息
                 GameActivity.this.m_Handler.sendMessage(message); //发送消息
                 Log.i("Thread run","yunxing22222");
                    try
                       {
                        Thread.sleep(100);   // 线程休眠时间
                       }
                    catch(InterruptedException e)
                       {
                        Thread.currentThread().interrupt();
                       }

                         m_time_a = ++i*100;   //循环获取时间的叠加值，满足一定条件是执行下落函数块
                      if(m_time_a == (10-2*m_GameView.levl+1)*100) //时间满足执行
                       {
                        onNotDown();   // 执行下落处理函数
                        i = 0; // 重置变量i
                       }
              }
          }
        }
        }


    public void onNotDown()
    {
    if(Thread_Log) //暂停标志
    {
        if(m_GameView.moveDownOn()) // 能够下落
          {
           m_GameView.Down();
           log_num = 0;
          }
        else
          {
       if(log_num == 0)
         MusicPlay.playSound(R.raw.down,0);
            m_GameView.NotDown();
            if(m_GameView.GameOver()) //游戏结束
                 {
              dialog_xx = 1;
                 }
            if(dialog_xx == 0)
               m_GameView.newState();

                if(m_GameView.gradeCourt >= 3000&&m_GameView.timeTask == 1000) //一定分数升级
                   {
               m_GameView.timeTask = 800;
                         m_GameView.levl+=1;
                   }
                if(m_GameView.gradeCourt >= 6000 && m_GameView.timeTask == 800)
                  {
               m_GameView.timeTask = 500;
                         m_GameView.levl+=1;
                         m_GameView.log_X = 0;
                  }
                if(m_GameView.gradeCourt >= 9000&&m_GameView.timeTask == 500)
                     {
               m_GameView.timeTask = 200;
                        m_GameView.levl+=1;
                        m_GameView.log_X = 0;
                     }

                     m_GameView.fastDown(1);


          }
    }
    }

      public boolean onTouch(View v, MotionEvent event) // 重写onTouch函数
       {
        return m_GestureDetector.onTouchEvent(event);   // 可以响应手势
       }

      public boolean onKeyDown(int key,KeyEvent keyevent)     //对按键的响应
{
       m_GameView.idKeyDown(key, keyevent);

  if(key == KeyEvent.KEYCODE_BACK && keyevent.getRepeatCount() == 0) //返回键提示对话框
  {
   Thread_Log = false;
   dialog();
   return true;
  }
  return true;//super.onKeyDown(key, keyevent);
}

protected void dialog() // 对话框函数
{
          AlertDialog.Builder builder = new Builder(GameActivity.this);
          builder.setMessage("确定要退出吗?");
          builder.setTitle("提示");
          builder.setPositiveButton("确认",
          new android.content.DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int which) {
               MusicPlay.releaseMusic();
                  dialog.dismiss();
                  android.os.Process.killProcess(android.os.Process.myPid());
              }
          });
          builder.setNegativeButton("取消",
          new android.content.DialogInterface.OnClickListener() {
              public void onClick(DialogInterface dialog, int which) {
                  dialog.dismiss();
                  Thread_Log = true;
              }
          });
          builder.create().show();
      }

protected void dialog_a()
{
          AlertDialog.Builder builder = new Builder(GameActivity.this);
          builder.setMessage("游戏结束！！！");
          builder.setTitle("提示");
          builder.setPositiveButton("确认",
          new android.content.DialogInterface.OnClickListener()
          {
              public void onClick(DialogInterface dialog, int which)
              {
               m_GameView = null;
               Intent intent = new Intent(GameActivity.this,WelcomeActivity.class);
               MusicPlay.releaseMusic();
           startActivity(intent);
                // GameActivity.this.finish();
              }
          });

          builder.create().show();
      }

    public void onDestroy() // 销毁函数
       {
        super.onDestroy();
        MusicPlay.releaseMusic();
       }


public boolean onDown(MotionEvent event) //按下触摸事件
{
    int x = (int)event.getX();   //获取按下的坐标位置
      int y = (int)event.getY();

      if(m_GameView.m_ButtonLeft.IsClick(x, y)) // 按下坐标是否在图标区域
      {
       vibrator.vibrate(pattern,-1); // 真机下按键震动响应

       if(m_GameView.moveLeftOn()&& Thread_Log)
       {
            m_GameView.Left();
             m_GameView.fastDown(1); // 计算此时与下方方块的最短距离，以便绘制透明方块
       }

       MusicPlay.playSound(R.raw.action,0);
      }

      if(m_GameView.m_ButtonRight.IsClick(x, y))
      {
          vibrator.vibrate(pattern,-1);

          if(m_GameView.moveRightOn()&& Thread_Log)
          {
              m_GameView.Right();
         m_GameView.fastDown(1);
          }

          MusicPlay.playSound(R.raw.action,0);
      }

      if(m_GameView.m_ButtonDown.IsClick(x, y))
      {
       m_GameView.buttonDown = true;
       vibrator.vibrate(pattern,-1);

       if(m_GameView.moveDownOn()&& Thread_Log)
       {
         m_GameView.Down();
         m_GameView.fastDown(1);
       }
      }

      if(m_GameView.m_ButtonRotate.IsClick(x, y))
      {
       m_GameView.buttonRotate = true;
       vibrator.vibrate(pattern,-1);

       if(m_GameView.rotateOnCourt()&& Thread_Log)
       {
              m_GameView.rate();
              m_GameView.fastDown(1);
       }

       MusicPlay.playSound(R.raw.action,0);
      }

      if(m_GameView.m_ButtonFastDown.IsClick(x, y))
      {
       m_GameView.buttonFastDown = true;
       vibrator.vibrate(pattern,-1);

       if(m_GameView.moveDownOn()&& Thread_Log)
       {
              m_GameView.FastDown();
       }

       MusicPlay.playSound(R.raw.fastdown,0);
      }

  return true;
}

public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,float velocityY)
    {
    final int FLING_MIN_DISTANCE = 100, FLING_MIN_VELOCITY = 200;

       if(e2.getY()-e1.getY()>FLING_MIN_DISTANCE && Math.abs(velocityY)>FLING_MIN_VELOCITY && m_GameView.moveDownOn()&& Thread_Log)
       {
            log_num = 1;
            m_GameView.FastDown();
            MusicPlay.playSound(R.raw.fastdown,0);
       }

       if(e2.getY()-e1.getY()<0&&Math.abs(velocityY)>FLING_MIN_VELOCITY)
       {
        if(log_log == 0)
        {
         Thread_Log = false;
         log_log = 1;
        }
        else
        {
         Thread_Log = true;
         log_log = 0;
        }

       }
    return false;
    }

public void onLongPress(MotionEvent event)
{
}

public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,float distanceY) {

   Log.i("onScroll","Downstill");

  if(e1.getAction() == MotionEvent.ACTION_DOWN)
    log = e1.getX();
      float e1x = e1.getX() ;
   float e2x = e2.getX() ;
   float x1 = e2x - e1x ;
   float e1y = e1.getY() ;
   float e2y = e2.getY() ;
   float y1 = e2y - e1y ;
   float absX = Math.abs(x1), absY = Math.abs(y1) ;
      float ex2 = e2.getX();
      float x = ex2-log;
   if(absX > absY)
   {
       if(x>60f&&x<70f || x>-70f&&x<-60f)
       {
       log = ex2;

                   if( x>-70f&&x<-60f&& m_GameView.moveLeftOn())
             {
            m_GameView.Left();
            m_GameView.fastDown(1);
            MusicPlay.playSound(R.raw.action,0);
             }
            if(x>60f&&x<70f && m_GameView.moveRightOn())
             {
            m_GameView.Right();
            m_GameView.fastDown(1);
            MusicPlay.playSound(R.raw.action,0);
             }
       }
   }

  return true;
}

public void onShowPress(MotionEvent event) {

}

public boolean onSingleTapUp(MotionEvent e) // 点击屏幕
{
  // TODO Auto-generated method stub
  if(e.getY()<400)
  {
   if(e.getX()<240 || e.getY()<300)
   {
    if(m_GameView.rotateOnCourt())
    {
     m_GameView.rate();
        m_GameView.fastDown(1);
        MusicPlay.playSound(R.raw.rotation,0);
    }

   }
  }
  return false;
}

     }

主要的都有了。虽然自己在还没有学C++,没有学java，没有学android，但我自己的自学程度，在短短的两个月内自学完。我只是想用自己的经历告诉大家，只要我们努力去做就会走向成功，就算不成功，这个历程也是值得我们回味的。。希望大家批评指正，如有更好的建议，希望大家多多交流。~~~~~~~~~~~·期待你们的意见。。

转载请注明出处~~~~~~~~~~~~~~~~~~~谢谢！！！！！！！！！！！！

下载地址我贴出来了，很早时候写的，大家勿喷啊。如果你能够修改我的代码欢迎交流了。

http://download.csdn.net/detail/wu10045125/8219063

另外小弟开源了一个项目也欢迎大家fork了，支持了。小弟github开源地址：

https://github.com/10045125/vanda

更多相关文章

随机推荐