Android版俄罗斯方块的实现

最新推荐文章于 2023-02-15 14:56:20 发布
最新推荐文章于 2023-02-15 14:56:20 发布
阅读量8.8k 收藏 27
点赞数 13
分类专栏： Android编程学习 文章标签： Android 俄罗斯方块 Android版俄罗斯方块 Android版俄罗斯 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1084283172/article/details/47904463
版权

学习Android的基本开发也有一段时间了，但是因为没有经常使用Android渐渐的也就忘记了。Android编程学的不深，仅仅是为了对付逆向，但是有时还是会感到力不从心的。毕竟不是一个计算机专业毕业的Coder，相对来说编程的基础对于以后很多方面的学习都是很重要的，特别是想在软件安全或软件的企业开发的过程中有所进步，必须要计算机专业知识扎实。

 

不多说了，发个Android版的俄罗斯方块，当然基本框架是参照之前的学的C语言版的俄罗斯方块的。俄罗斯方块程序的开发方法比较多，感觉使用数组的方法去实现还是很方便的，下面看代码的具体实现。


俄罗斯方块界面显示代码的实现：

//俄罗斯方块界面的显示

package com.example.mytetris;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.View;
import android.view.WindowManager;

public class GameUI extends View
{
	public Game m_Game = null;
    private byte[][] m_Groundback = null;
    
    private Paint m_Paint = new Paint(); //画刷
    private final int PADDING = 2;   
    private int m_TetrisWidth = 0;
    
    @Override
    protected void onDraw(Canvas canvas) 
    { 
		//设置背景颜色
		setBackgroundColor(Color.BLACK);
		
		//画背景
		drawGoundback(canvas);
		
		//画方块
		int nX = m_Game.m_nX;
		int nY = m_Game.m_nY;
		
		if (m_Game.m_CurrBlock == null)
			return;
		
		byte[][] data = m_Game.m_CurrBlock;
		for (int i = 0; i < 4; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				if (data[i][j] == Game.ISWALL)	
				{
					int nLeft = nX * m_TetrisWidth  + j * m_TetrisWidth;
					int nTop = nY * m_TetrisWidth +  i * m_TetrisWidth;
					
					//外框
					m_Paint.setColor(Color.WHITE);
					canvas.drawRect(nLeft, nTop, nLeft + m_TetrisWidth, 
									nTop + m_TetrisWidth, m_Paint);
					
					//内框
					m_Paint.setColor(Color.GREEN);
					canvas.drawRect(nLeft + PADDING, nTop + PADDING, 
									nLeft + m_TetrisWidth - PADDING, nTop +m_TetrisWidth - PADDING, m_Paint);
				}
			}
		}
    }

    private void drawGoundback(Canvas canvas)
    {
    	//获取背景
		m_Groundback = m_Game.getGroundback();
		
		for (int i = 0; i < Game.NROWS; i++) 
		{
		    for (int j = 0; j < Game.NCOLS; j++) 
		    {
			if (m_Groundback[i][j] == Game.ISWALL)
				{
				    //画白色的方块--外框
				    m_Paint.setColor(Color.WHITE);
				    canvas.drawRect(j*m_TetrisWidth, i*m_TetrisWidth, 
					    	   (j+1)*m_TetrisWidth, (i+1)*m_TetrisWidth, m_Paint);
				    
				    //画绿色的方块--内框
				    m_Paint.setColor(Color.GREEN);
				    canvas.drawRect(j*m_TetrisWidth + PADDING, i*m_TetrisWidth + PADDING,
					           (j+1)*m_TetrisWidth - PADDING, (i+1)*m_TetrisWidth - PADDING, m_Paint);
				}
		    }
		}
    }
    
    public GameUI(Context context, AttributeSet attrs, int defStyleAttr)
    {
    	super(context, attrs, defStyleAttr);
    	
    }
    
    //自定义view组件，构造调用该函数
    public GameUI(Context context, AttributeSet attrs)
    {
    	super(context, attrs);
    	
    	//创建Game
    	m_Game = new Game();
    	
    	//获取手机分辨率
    	WindowManager wmgr = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE);
		DisplayMetrics outMetrics = new DisplayMetrics();
		wmgr.getDefaultDisplay().getMetrics(outMetrics);
		//手机屏幕宽度
		int nTetrisWidth = outMetrics.widthPixels;
    	
    	//根据手机分辨率，设置方块宽度
    	m_TetrisWidth = nTetrisWidth/Game.NCOLS*3/4;
    	
    }
    
    public GameUI(Context context)
    {
    	super(context);
    	
    }

}


俄罗斯方块具体的逻辑的实现：
 
package com.example.mytetris;

import java.util.Arrays;
import java.util.Random;

import android.R.integer;

public class Game 
{
	public static final byte ISWALL = 1; //墙
	public static final int NROWS = 20;  //18行
	public static final int NCOLS = 12;  //12列
	public byte[][] m_Groundback = null;
	
	public int m_nX = 0;   //方块x坐标
	public int m_nY = 0;   //方块y坐标
	private Random m_Random = new Random(); //产生随机对象
	
	private byte[][][] m_Tetris = null;  //方块的各种变化
	public byte[][] m_CurrBlock = new  byte[4][4]; //当前方块
	private byte[][] m_NextBlock = new  byte[4][4]; //下一个方块
	
	public Game()
	{
		m_Groundback = new byte[NROWS][NCOLS];	
		
		initGroundback();
		initTetris();
	}
	
	//初始化背景
	public void initGroundback()
	{
		for (int i = 0; i < NROWS; i++)
		{
			for (int j = 0; j < NCOLS; j++)
			{
				if (i == NROWS - 1 || j == 0 || j == NCOLS - 1)
				{
				    //设置墙
				    m_Groundback[i][j] = ISWALL;
				}
			}
		}
	}
	
	//初始化变换方块的类型
	public void initTetris()
	{
		//这种初始化不能给维数
	    m_Tetris = new byte [][][]
		{
	    	/*1*/
			{
				{1, 1, 1, 1},
				{0, 0, 0, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*2*/
			{
				{1, 0, 0, 0},
				{1, 0, 0, 0}, 
				{1, 0, 0, 0},
				{1, 0, 0, 0}
			},
			
			/*3*/
			{
				{1, 0, 0, 0},
				{1, 1, 0, 0}, 
				{0, 1, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*4*/
			{
				{0, 1, 0, 0},
				{1, 1, 0, 0}, 
				{1, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*5*/
			{
				{1, 1, 0, 0},
				{0, 1, 1, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*6*/
			{
				{0, 1, 1, 0},
				{1, 1, 0, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*7*/
			{
				{0, 1, 0, 0},
				{1, 1, 1, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*8*/
			{
				{1, 1, 1, 0},
				{0, 1, 0, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*9*/
			{
				{1, 0, 0, 0},
				{1, 1, 0, 0}, 
				{1, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*10*/
			{
				{0, 1, 0, 0},
				{1, 1, 0, 0}, 
				{0, 1, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*11*/
			{
				{1, 1, 0, 0},
				{0, 1, 0, 0}, 
				{0, 1, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*12*/
			{
				{1, 1, 0, 0},
				{1, 0, 0, 0}, 
				{1, 0, 0, 0},
				{0, 0, 0, 0}
			},
	    		
			/*13*/
			{
				{1, 0, 0, 0},
				{1, 1, 1, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
			
			/*14*/
			{
				{1, 1, 1, 0},
				{0, 0, 1, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
	    		
			/*15*/
			{
				{1, 1, 0, 0},
				{1, 1, 0, 0}, 
				{0, 0, 0, 0},
				{0, 0, 0, 0}
			},
	    };
	    
	}
	
	//获取背景
	public byte[][] getGroundback()
	{
	    return m_Groundback;
	}

	//开始游戏
	public void startGame()
	{
		m_nX = NCOLS / 2 - 2;
		m_nY = 0;

		// 产生方块
		m_CurrBlock = RandomBlock();
		m_NextBlock = RandomBlock();
	}
	
	//结束游戏
	public void stopGame()
	{
	    
	}
	
	//左移
	public void moveLeft()
	{
		if (IsCanMove(m_nX - 1, m_nY))
		{
			m_nX--;
		}
	}
	
	//右移
	public void moveRight()
	{
		if (IsCanMove(m_nX + 1, m_nY))
		{
			m_nX++;
		}
	}
	
	//方块变换时，变换方块--这个产生的问题还没解决?
	public byte[][] getNextBlock()
	{
		//产生一个随机数
	    int nLen = m_Tetris.length;
	    //右移高位补0--去掉符号位
	    int nIndex = (m_Random.nextInt() >>> 1) % nLen;
	    
		return m_Tetris[(nIndex+2)%15];
	}
	
	//变换
	public void moveChange()
	{
		byte[][] oldBlock = m_CurrBlock;
		m_CurrBlock = getNextBlock();
		if (!IsCanMove(m_nX, m_nY))
		{
			m_CurrBlock = oldBlock;
		}
	}
	
	//下移
	public void moveDown()
	{
		if (IsCanMove(m_nX, m_nY + 1))
		{
			m_nY++;
		} 
		else
		{
			Fixbircks();	
		}
	}
	
	//随机产生方块
	public byte[][] RandomBlock()
	{
		 //产生一个随机数
		  int nLen = m_Tetris.length;
		  //右移高位补0--去掉符号位
		  int nIndex = (m_Random.nextInt() >>> 1) % nLen;
		  
		  return m_Tetris[nIndex];
	}
	
	//产生方块
	private void CreateBircks()
	{
		m_nX = NCOLS / 2 - 2;
		m_nY = 0;

		// 产生方块
		m_CurrBlock = m_NextBlock;
		m_NextBlock = RandomBlock();
	}

	//下移到底
	public void MoveFix()
	{
		while (IsCanMove(m_nX, m_nY + 1))
		{
			m_nY++;
		}
		
		Fixbircks();
	}
	
	//判断方块能否移动
	private boolean IsCanMove(int x, int y)
	{
		byte[][] data = m_CurrBlock;

		for (int i = 0; i < 4; i++)
		{
			for (int j = 0; j < 4; j++)
			{
				if (data[i][j] == ISWALL
						&& m_Groundback[y + i][x + j] == ISWALL)
				{
					return false;
				}
			}
		}

		return true;
	}

	//固定方块
	private  void Fixbircks()
	{
	  byte[][] data = m_CurrBlock;
		
	  for (int i = 0; i < 4; i++)
	  {
	    for (int j = 0; j < 4; j++)
	    {
	      //填充背景
	      if (data[i][j] == ISWALL)
	      {
	        m_Groundback[m_nY + i][m_nX + j] = ISWALL;
	      }
	    }
	  }

	  int nRows = ReleaseRows();

	  //产生新方块
	  CreateBircks();

	  //新方块不能移动，结束游戏
	}

	//消除方块
	private int ReleaseRows()
	{
		  int nReleaseRows = 0;

		  for (int nRow = NROWS - 2; nRow > 0; nRow--)
		  {
		    if (IsCanRelease(nRow))
		    {
		      //消除方块
		      nReleaseRows++;
		      //调整方块--下移
		      MoveRows(nRow);
		      
		    //重新判断本行是否可以消行
		      nRow++; 
		    }
		  }

		  return nReleaseRows;
	}

	//能否消除方块
	private boolean IsCanRelease(int nRow)
	{
		  for (int nCol = 1; nCol < NCOLS - 1; nCol++)
		  {
		    if (m_Groundback[nRow][nCol] == 0)
		    {
		      return false;
		    }
		  }
		  return true;
	}

	//消除方块以后，下移方块
	private void MoveRows(int nRow)
	{
		  for (int i = nRow; i > 0; i--)
		  {
		    for (int j = 1; j < NCOLS - 1; j++)
		    {
		      m_Groundback[i][j] = m_Groundback[i - 1][j];
		    }
		  }
	}

}


俄罗斯方块主体的控制流程的代码实现： 


package com.example.mytetris;

import java.util.Timer;
import java.util.TimerTask;


import android.media.MediaPlayer;
import android.os.Bundle;
import android.app.Activity;
import android.util.DisplayMetrics;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;

public class MainActivity extends Activity implements OnClickListener
{
	private GameUI m_GameUi = null;
	private Game   m_Game   = null;
	
	private Button btnLeft = null;
	private Button btnRight = null;
	private Button btnDown = null;
	private Button btnChange = null;
	
	private MediaPlayer mp2 = null;

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		//设置全屏无标题显示
		this.requestWindowFeature(Window.FEATURE_NO_TITLE);
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
				     WindowManager.LayoutParams.FLAG_FULLSCREEN);
		
		super.onCreate(savedInstanceState);
		setContentView(R.layout.linearlayout);
		
		//获取组件
		m_GameUi = (GameUI)findViewById(R.id.GameUI);
		m_Game   = m_GameUi.m_Game;
		
		btnLeft = (Button)findViewById(R.id.button1_left);
		btnRight = (Button)findViewById(R.id.button2_right);
		btnDown = (Button)findViewById(R.id.button3_down);
		btnChange = (Button)findViewById(R.id.button4_change);
		
		//设置监听
		btnLeft.setOnClickListener(this);
		btnRight.setOnClickListener(this);
		btnDown.setOnClickListener(this);
		btnChange.setOnClickListener(this);
		
		//
		mp2 = MediaPlayer.create(this, R.raw.action);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) 
	{
		getMenuInflater().inflate(R.menu.gamemenu, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		int nIndex = item.getItemId();
		switch (nIndex) 
		{
		case R.id.item1_startgame:
			{
				//开始游戏
				m_Game.startGame();
				m_GameUi.invalidate();
				
				//播放音效
				MediaPlayer mp = MediaPlayer.create(this, R.raw.ready_go);
				mp.start();
				//mp.release();
				
				//定时器
				new Timer().schedule(new TimerTask()
				{
					@Override
					public void run() 
					{
						m_GameUi.m_Game.moveDown();
						m_GameUi.invalidate();
						
						mp2.start();
					}
				}, 0, 2000);
				
				//线程
//				new Thread(new Runnable()
//				{
//					@Override
//					public void run()
//					{
//						try
//						{
//							Thread.sleep(1000);
//						} 
//						catch (InterruptedException e)
//						{
//							e.printStackTrace();
//						}
//						
//						m_GameUi.m_Game.moveDown();
//						m_GameUi.invalidate();
//						
//					}
//				}).start();
				
			}
			break;
		case R.id.item2_restartgame:
			{
				
			}
			break;
		case R.id.item3_stopgame:
		{
			
		}
		break;
		default:
			break;
		}
		return super.onOptionsItemSelected(item);
	}
	@Override
	public void onClick(View v) 
	{
		int nId = v.getId();
		switch (nId)
		{
		case R.id.button1_left:
			{
				m_Game.moveLeft();
			}
			break;
		case R.id.button2_right:
			{
				m_Game.moveRight();
			}
			break;
		case R.id.button3_down:
			{
				m_Game.MoveFix();
			}
			break;
		case R.id.button4_change:
			{
				m_Game.moveChange();
			}
			break;
		default:
			break;
		}
		
		//重绘
		m_GameUi.invalidate();
	}

}



运行效果图，界面做的比较挫：






Android俄罗斯方块的代码实现还不全，有兴趣的Coder可以完善一下。网上Android版俄罗斯方块代码到处都是，但是我觉得这份代码给出了俄罗斯方块编写的基本框架，按照这个框架，可以写出很多语言版本的俄罗斯方块。



代码下载地址：http://download.csdn.net/detail/qq1084283172/9037683



Fly20141201
关注
专栏目录
Android版俄罗斯方块
08-23
发个不是很完整的Android版俄罗斯方块，有兴趣的同学可以继续完善一下俄罗斯方块的代码，实现一个比较OK 的Android版俄罗斯方块。
android版俄罗斯方块
01-11
android 版的俄罗斯方块，自己的第一个游戏经验不多，所以代码写的不是很优美，仅供初学者参考，感谢大家的下载
安卓小游戏：俄罗斯方块
最新发布
silencefly的博客
02-15 1144
还原经典游戏：俄罗斯方块，左右移动、向上变换、向下快速降落，满一层就消除，是你小时候的味道吗？
基于android的俄罗斯方块的设计与实现
11-22
在android平台上开发俄罗斯方块游戏，包括实现的的原理、架构、过程，适合大学生课程设计的学习。
基于Android的俄罗斯方块的设计与实现完整版样本.doc
12-17
"基于Android的俄罗斯方块的设计与实现完整版样本" 基于Android的俄罗斯方块游戏设计和实现需要结合Android操作系统的特点和俄罗斯方块游戏的规则来进行设计和实现。下面是相关的知识点： 一、Android操作系统概述...
android版俄罗斯方块源码
11-30
通过深入研究这个“安卓版俄罗斯方块源码”，开发者不仅可以学习到Android应用开发的基本技能，还能掌握游戏开发的特定技巧，如游戏循环、碰撞检测和动画实现等。同时，这也是一个很好的实践项目，有助于提升解决...
android俄罗斯方块开发代码,基于Android的俄罗斯方块开发（附源码）
weixin_39608116的博客
05-26 853
最近在学Android开发，一直想找个项目来练练手，前段时间在考试也没有时间，不过那时候就有点想法，就是想做个俄罗斯方块或者贪吃蛇什么的。然后一直到这几天才有时间来写这个项目。完成这个项目主要有几个问题要处理：① 边界问题，即如何判断俄罗斯方块是否已经到达边界，主要是在左右移动和下降过程中，判断俄罗斯方块是否已经抵达边界，使其不超越边界。② 接触问题，即如何判断俄罗斯方块已经与其他俄罗斯方块接触，...
android 实现俄罗斯方块游戏 代码 好玩
06-23
android 实现俄罗斯方块游戏 代码 好玩 方块是不同的颜色 可以加速 基本上实现俄罗斯方块全部功能
Android俄罗斯方块（原创）
03-28
这是我自己开发的Android俄罗斯方块的源码，使用原生API开发，基本功能完备，亲测可以运行。写得不好，欢迎大家批评指正。
android俄罗斯方块
10-09
资源：安卓俄罗斯方块小游戏 作者：欧小帅 日期：2016-10-2 语言：android 工具：android studio
Android 俄罗斯方块游戏
03-24
NULL 博文链接：https://kkkawp.iteye.com/blog/1028286
俄罗斯方块
12-03
只能在320*480分辨率下运行，由于这个是我很早时候写的，本来想重写的，结果实在抽不出时间，大家那么需要源代码，我就贴出来吧。如果你参照我的能做的更好，希望交流落。
第2个android程序-俄罗斯方块
m0_37677599的博客
08-08 499
最近学习java开发，就编写第2个android程序 俄罗斯方块。 一、设计思路： ​ 1. 每个俄罗斯方块都由四个小方格组成，故把小方格作为一个类。一个方块下落、左移、右移、旋转，最终都转化为小方格位置的改变。 ​ 定义小方格类两个属性：在第几行row、第几列col，并实现四个方法：上移、下移、左移、右移。 ​ 为啥会有上移，因为俄罗斯方块旋转是由这四个方法组成。另外实现拷贝方法 ​ public class Cell implements Cloneable { priv
关于Android开发俄罗斯方块
lesley_w的博客
08-01 495
接上一篇数据库的注意点。 使用visual studio开发web 我用的是visual studio2010，新建项目，选择ASP.NET Web服务应用程序，修改项目名称，我命名为AndroidLinkSql。 Visual studio的下载安装可以参考软件安装管家，选择.NET Framework 3.5下的ASP.NET Web服务应用程序，如果没有百度一下，下载个插件就有了。 新建一个...
android俄罗斯方块源码 带触屏（原创）
09-29
android俄罗斯方块,有详细的注释！界面美观，12生肖组成不同块。有特殊块增加，消减，穿心，炸弹。 背景可选，有声音震动。有首页跑动特效，排行榜，菜单设置等。非常全。上一个版本http://download.csdn.net/detail/yycaogg/5671697 c#版http://download.csdn.net/detail/yycaogg/5673969
安卓俄罗斯方块源码（支持WIFI对战）
11-30
本压缩包包含安卓版俄罗斯方块源码...................
Android版俄罗斯方块设计与实现
"基于Android的俄罗斯方块的设计与实现" 这篇文档是关于在Android平台上设计和实现俄罗斯方块游戏的课程设计报告。报告涵盖了游戏的介绍、需求分析、总体设计、详细设计与实现以及总结，旨在阐述如何利用Android...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值