如何改编俄罗斯方块

㈠ 如何用C语言编一个俄罗斯方块

游戏界面预览：

菜单预览：

自定义每个小方块颜色功能界面：

游戏主要有四部分组成：Square类，Block类，gameField类，游戏引擎

Square类：
这个类描述的对象是组成大方块中的每个小正方形实体。
类设计：
class Square
{
public Point location; //小方块的坐标
public Size size; //小方块大小
public Color foreColor; //小方块前景色
public Color backColor; //小方块背景色
public Square(Size initSize,Color initForeColor,Color initBackColor) //构造函数
{ ……}
public void Draw(System.IntPtr winHandle) //在指定设备上画方块
{ …… }
public void Erase(System.IntPtr winHandle)//擦除方块
{ …… }
}

Block类：
这个类描述的对象是某一个大方块的实体。每个大方块由四个小正方形组成，一共有7种组合方式。这个类需要实现一个大方块实体所有的属性和动作。包括：方块的形状，位置，方块左移，右移，下移，旋转等。
类设计：
class Block
{
public Square square1; //组成block的四个小方块
public Square square2;
public Square square3;
public Square square4; private const int squareSize = GameField.SquareSize; //小方块的边长
public enum BlockTypes
{
undefined = 0,
square = 1,
line = 2,
J = 3,
L = 4,
T = 5,
Z = 6,
S = 7
};//一共有7种形状
public BlockTypes blockType; //方块的形状
//七个小方块的颜色数组
private Color foreColor;
private Color backColor;
//方块的方向
public enum RotateDirections
{
North = 1,
East = 2,
South = 3,
West = 4
};
public RotateDirections myRotation = RotateDirections.North;

public Block(Point thisLocation,BlockTypes bType)
{ ……}
//含有自定义颜色的重载
public Block(Point thisLocation, BlockTypes bType,Color fc,Color bc)
{ ……} /*画方块*/
public void Draw(System.IntPtr winHandle)
{…… }
/*擦方块*/
public void Erase(System.IntPtr winHandle)
{…… } /*移动*/
public bool down()
{……}
public bool left()
{……}
public bool right()
{……}
/*旋转block*/
public void Rotate()
{……}
/*检测是否到顶*/
public int Top()
{……}
}

GameField类：
这个类描述的对象是游戏场景实体，包括场景的背景色，大小，方块是否还可以移动，以及场景中填满一行的检测等。
类设计：
class GameField
{
public const int width = 20; //场景的宽，以方块个数为单位
public const int height = 30;
public const int SquareSize = 15; //每个四分之一小方块的边长
public static Color BackColor; //场景的背景色
public static System.IntPtr winHandle; //场景的handle
public static Color[] BlockForeColor ={ Color.Blue, Color.Beige, Color.DarkKhaki, Color.DarkMagenta, Color.DarkOliveGreen, Color.DarkOrange, Color.DarkRed };
public static Color[] BlockBackColor ={ Color.LightCyan, Color.DarkSeaGreen, Color.Beige, Color.Beige, Color.Beige, Color.Beige, Color.Beige };
public static bool isChanged=false; //设置是否被更改的标志位
public static SoundPlayer sound = new SoundPlayer(); //播放声音 public static Square[,] arriveBlock = new Square[width, height]; //保存已经不能再下落了的方块
public static int[] arrBitBlock=new int[height]; //位数组：当某个位置有方块时，该行的该位为1
private const int bitEmpty = 0x0; //0000 0000 0000 0000 0000
private const int bitFull = 0xFFFFF; //1111 1111 1111 1111 1111 /*检测某个位置是否为空*/
public static bool isEmpty(int x, int y)
{……}
/*将方块停住*/
public static void stopSquare(Square sq, int x, int y)
{……}
/*检测行是否满
* 返回：成功消除的行数和 （方便统计分数）
*/
public static int CheckLines()
{ ……}
/*播放声音*/
public static void PlaySound(string soundstr)
{……}
/*重画*/
public static void Redraw()
{ …… }
//结束
}

游戏引擎：
游戏引擎正如其名，就像一个发动机一样让游戏不间断运行。本游戏中就是让方块以一定的速度下落。并响应键盘事件，实行左右移动，和向下加速功能。（代码见源码）

声音播放：

音效是游戏不可缺少的一部分。在.Net2.0中已经提供了一个类来播放声音。在using System.Media;命名空间。
本游戏中播放声音的代码如下：（在 GameField类中）
using System.Media;

public static SoundPlayer sound = new SoundPlayer();

/*播放声音*/
public static void PlaySound(string soundstr)
{
switch (soundstr)
{
case "FinishOneLine": //消除一行的声音
if (!File.Exists("FinishOneLine.wav")) return;
sound.SoundLocation = "FinishOneLine.wav";
break;
case "CanNotDo": //当无法操作时
if (!File.Exists("CanNotDo.wav")) return;
sound.SoundLocation = "CanNotDo.wav";
break;
}
sound.Play();
}
要播放的时候调用PlaySound（）方法即可。
其实步骤很简单，先引用System.Media空间，然后创建一个SoundPlayer 对象，用SoundLocation 属性设置声音文件的地址，然后调用Play()方法即可播放。不过注意，这个类可以播放的声音格式只有Wav文件。

保存游戏设置：
在游戏中经常要保存用户自定义的设置。本游戏通过写进ini文件来保存。
主要代码如：

/*加载窗体时从配置文件Setting.ini中读取游戏设置*/
private void getSettings()
{
if (!File.Exists("Setting.ini"))
return;
FileStream fs = new FileStream("Setting.ini", FileMode.OpenOrCreate, FileAccess.ReadWrite);
StreamReader sr = new StreamReader(fs);
string line1=sr.ReadLine();
string line2=sr.ReadLine();
string line3=sr.ReadLine();
if (line1 != null && line1.Split('=').Length > 1)
{
GameField.BackColor = Color.FromArgb(int.Parse(line1.Split('=')[1]));
picBackGround.BackColor = GameField.BackColor;
}
if (line2 != null && line2.Split('=').Length > 1)
GameField.BlockForeColor = strToColor(line2.Split('=')[1]);
if (line3 != null && line3.Split('=').Length > 1)
GameField.BlockBackColor = strToColor(line3.Split('=')[1]);
sr.Close();
fs.Close();
}
/*如果游戏设置被更改，将新的设置保存到Setting.ini*/
private void saveSettings()
{
FileStream fs = new FileStream("Setting.ini", FileMode.Create, FileAccess.ReadWrite);
StreamWriter sw = new StreamWriter(fs);
sw.WriteLine("GameFieldColor="+GameField.BackColor.ToArgb());
sw.WriteLine("BlockFroeColor=" + colorToStr(GameField.BlockForeColor));
sw.WriteLine("BlockBackColor=" + colorToStr(GameField.BlockBackColor));
sw.Flush();
sw.Close();
fs.Close();
}
要源码+QQ348199903

㈡ vb6.0如何编写俄罗斯方块

using System;
using System.Drawing;
using Microsoft.Win32;

namespace AnotherBlock
{
/// <summary>
/// Represents a Tetris game engine.
/// </summary>
public class Game
{
/// <summary>
/// Constant with the image width of the block unit (in pixels).
/// </summary>
public const int BlockImageWidth = 21;
/// <summary>
/// Constant with the image height of the block unit (in pixels).
/// </summary>
public const int BlockImageHeight = 21;
/// <summary>
/// Constant with the playing field width (in block units).
/// </summary>
public const int PlayingFieldWidth = 10;
/// <summary>
/// Constant with the playing field height (in block units).
/// </summary>
public const int PlayingFieldHeight = 20;
/// <summary>
/// Constante with the number of lines for each level.
/// </summary>
public const int LevelEveryLines = 12;

/// <summary>
/// Private attribute that holds the current game score.
/// </summary>
private int score = 0;
/// <summary>
/// Private attribute that holds the current game level.
/// </summary>
private short level = 1;
/// <summary>
/// Private attribute that holds the current number of completed lines.
/// </summary>
private int lines = 0;
/// <summary>
/// Private attribute that holds the current game state.
/// </summary>
private GameState gameState;
/// <summary>
/// Private attribute that holds the level where the game started.
/// </summary>
private short startLevel = 1;
/// <summary>
/// Private attribute that holds the current game pile.
/// </summary>
private Brick[,] pile = new Brick[(PlayingFieldWidth + 1), (PlayingFieldHeight + 1)];
/// <summary>
/// Private attribute that holds the current block.
/// </summary>
private Block currentBlock = new Block();
/// <summary>
/// Private attribute that holds the next block.
/// </summary>
private Block nextBlock = new Block();

/// <summary>
/// Class constructor that creates a game.
/// </summary>
public Game()
{
// Clears the game pile.
ClearPile();
}

/// <summary>
/// Class constructor that creates a game in a given level.
/// </summary>
/// <param name="level">The level where the game should start.</param>
public Game(short level)
{
// Sets the level attribute to the game level where the game should start.
this.level = level;
// Sets the startLevel attribute to the game level where the game should start.
startLevel = level;
// Clears the game pile.
ClearPile();
}

/// <summary>
/// Readonly property that holds the score of the current game.
/// </summary>
public int Score
{
get
{
// Returns the value in the score attribute.
return score;
}
}

/// <summary>
/// Readonly property that holds the level of the current game.
/// </summary>
public short Level
{
get
{
// Returns the value in the level attribute.
return level;
}
}

/// <summary>
/// Readonly property that holds the number of complete lines in the current game.
/// </summary>
public int Lines
{
get
{
// Returns the value in the lines attribute.
return lines;
}
}

/// <summary>
/// Property that holds and sets the current game state.
/// </summary>
/// <remarks>
/// The game state can be "Running", "Paused" or "Over".
/// </remarks>
public GameState GameState
{
get
{
// Returns the value in the gameState attribute.
return gameState;
}
set
{
// Checks if the current game state is "Over", and if the value to change is not "Over".
if ((gameState == GameState.Over) && (value != GameState.Over))
{
// The current game state is "Over", and it's changing to something else than "Over".
// Resets the score, level and lines.
score = 0;
level = startLevel;
lines = 0;
// Creates a new current block, and a new next block.
currentBlock = new Block();
nextBlock = new Block();
// Clears the game pile.
ClearPile();
}

// Sets the gameState attribute to the value.
gameState = value;
}
}

/// <summary>
/// Method that moves the current block down one position.
/// </summary>
/// <returns>True if there was a hit on the ground or on the pile, false if there wasn't.</returns>
public bool MoveCurrentBlockDown()
{
// Creates a "hit" flag, to check if the block has hit the pile or the ground.
bool hit = false;

// Increases the Top of the current block.
currentBlock.Top++;

// Checks if the current block has hit the ground.
// COLLISION DETECTION
if ((currentBlock.Top + currentBlock.Height) > PlayingFieldHeight)
{
// Current block has hit the ground.
// Sets the "hit" flag to "true".
hit = true;
}
else
{
// Checks if the current block has hit the pile.
// COLLISION DETECTION
for(int i = 0; i < currentBlock.Width; i++)
{
for(int j = 0; j < currentBlock.Height; j++)
{
int fx, fy;
fx = currentBlock.Left + i;
fy = currentBlock.Top + j;
if ((currentBlock.Shape[i, j].Filled == true) && (pile[fx, (fy + 1)].Filled == true))
{
// Current block has hit the pile.
// Sets the "hit" flag to "true".
hit = true;
}
}
}
}

// Checks if there was a hit.
if (hit)
{
// There was a hit.
// Puts the current block in the pile.
MoveBlockToPile();
// Checks if the current game state is not "Over".
if (this.GameState != GameState.Over)
{
// Current game state is not "Over".
// Creates a new block.
CreateNewBlock();
}
}

// Returns if there was a hit or not.
return hit;
}

/// <summary>
/// Method that moves the current block down until there is a hit.
/// </summary>
public void ()
{
// Moves the current block down until it has a hit.
while(!MoveCurrentBlockDown());
}

/// <summary>
/// Method that rotates the current block.
/// </summary>
/// <param name="clockwise">True if the block will be rotated clockwise, false if counterclockwise.</param>
public void RotateCurrentBlock(bool clockwise)
{
// Creates a "canRotate" flag, to check if the block can be rotated.
bool canRotate = true;

// Rotates the current block.
// This should be different. There should be an easy way to check FIRST if the block could
// be rotated, and then rotate it. I'll study this later.
currentBlock.Rotate(clockwise);

// Checks if the current block could be rotated.
// COLLISION DETECTION
for(int i = 0; i < currentBlock.Width; i++)
{
for(int j = 0; j < currentBlock.Height; j++)
{
int fx, fy;
fx = currentBlock.Left + i;
fy = (currentBlock.Top + 1) + j;
if ((currentBlock.Shape[i, j].Filled == true) && (pile[fx, fy].Filled == true))
{
// Current block can't be rotated.
// Sets the "canRotate" flag to "false".
canRotate = false;
}
}
}

// Checks if the block can't be rotated.
if (!canRotate)
{
// Block can't be rotated.
// Rotates the block back to its first position.
currentBlock.Rotate(!clockwise);
}
}

/// <summary>
/// Method that moves the current block to the right or to the left.
/// </summary>
/// <param name="left">True if the block will be moved to the left, false if to the right.</param>
public void MoveCurrentBlockSide(bool left)
{
// Creates a "canMove" flag, to check if the block can be moved to the sides.
bool canMove = true;

// Checks if the block is to be moved to the left.
if (left)
{
// The block is to be moved to the left.
// Checks if the block is not already at the most left of the playing field.
if (currentBlock.Left > 0)
{
// Block is not at the most left of the playing field.
// Checks if the current block can move to the left.
// COLLISION DETECTION
for(int i = 0; i < currentBlock.Width; i++)
{
for(int j = 0; j < currentBlock.Height; j++)
{
int fx, fy;
fx = currentBlock.Left + i;
fy = (currentBlock.Top + 1) + j;
if ((currentBlock.Shape[i, j].Filled == true) && (pile[(fx - 1), fy].Filled == true))
{
// Current block can't move to the left.
// Sets the "canMove" flag to "false".
canMove = false;
}
}
}

// Checks if the block can be moved to the left.
if (canMove)
{
// Block can be moved to the left.
// Moves the block to the left.
currentBlock.Left--;
}
}
}
else
{
// The block is not to be moved to the left (it is to be moved to the right).
// Checks if the block is not already at the most right of the playing field.
if ((currentBlock.Left + currentBlock.Width) < PlayingFieldWidth)
{
// Block is not at the most right of the playing field.
// Checks if the current block can move to the right.
// COLLISION DETECTION
for(int i = 0; i < currentBlock.Width; i++)
{
for(int j = 0; j < currentBlock.Height; j++)
{
int fx, fy;
fx = currentBlock.Left + i;
fy = (currentBlock.Top + 1) + j;
if ((currentBlock.Shape[i, j].Filled == true) && (pile[(fx + 1), fy].Filled == true))
{
// Current block can't move to the right.
// Sets the "canMove" flag to "false".
canMove = false;
}
}
}

// Checks if the block can be moved to the right.
if (canMove)
{
// Block can be moved to the right.
// Moves the block to the right.
currentBlock.Left++;
}
}
}
}

/// <summary>
/// Method that draws the pile in a surface.
/// </summary>
/// <param name="drawingSurface">The graphics surface where the pile will be drawn.</param>
public void DrawPile(Graphics drawingSurface)
{
// Runs through the playing field Width.
for (int i = 0; i < (PlayingFieldWidth + 1); i++)
{
// Runs through the playing field Height.
for (int j = 0; j < (PlayingFieldHeight + 1); j++)
{
// Checks if the current brick of the pile is set to be solid.
if (pile[i, j].Filled == true)
{
// Current brick of the pile is set to be solid.
// Creates a rectangle in the right position of this brick.
Rectangle rect = new Rectangle(i * BlockImageWidth, (j - 1) * BlockImageHeight, BlockImageWidth, BlockImageHeight);
// Draws the block image in the just created rectangle.
drawingSurface.DrawImage(pile[i, j].BrickImage, rect);
}
}
}
}

/// <summary>
/// Method that draws the current block in a surface.
/// </summary>
/// <param name="drawingSurface">The graphics surface where the current block will be drawn.</param>
public void DrawCurrentBlock(Graphics drawingSurface)
{
// Checks if there is a current block.
if (currentBlock != null)
{
// There is a current block.
// Draws the current block in the drawing surface.
currentBlock.Draw(drawingSurface);
}
}

/// <summary>
/// Method that draws the next block in a surface.
/// </summary>
/// <param name="drawingSurface">The graphics surface where the current block will be drawn.</param>
public void DrawNextBlock(Graphics drawingSurface)
{
// Checks if there is a next block.
if (nextBlock != null)
{
// There is a next block.
// Saves the current Left and Top properties of the next block.
short currentLeft = nextBlock.Left;
short currentTop = nextBlock.Top;

// Changes the current Left and Top properties of the next block, so they can be shown
// in the center of a drawing surface that has a size of 6x6 blocks.
nextBlock.Left = (short)((6 - nextBlock.Width) / 2);
nextBlock.Top = (short)((6 - nextBlock.Height) / 2);

// Draws the next block in the drawing surface.
nextBlock.Draw(drawingSurface);

// Retrieves the previously saved Left and Top properties, and put them back in the next block.
nextBlock.Left = currentLeft;
nextBlock.Top = currentTop;
}
}

/// <summary>
/// Private method that clears the current game pile.
/// </summary>
private void ClearPile()
{
// Runs through the playing field Width.
for(int i = 0; i < (PlayingFieldWidth + 1); i++)
{
// Runs through the playing field Height.
for(int j = 0; j < (PlayingFieldHeight + 1); j++)
{
// Clears the current brick of the pile.
pile[i, j].Filled = false;
}
}
}

/// <summary>
/// Private method that creates a new current block by getting it from the next block,
/// and creates a new random next block.
/// </summary>
private void CreateNewBlock()
{
// Checks if there is a next block.
if (this.nextBlock != null)
{
// There is a next block.
// Sets the current block to the next block.
currentBlock = nextBlock;
}
else
{
// There isn't a next block.
// Sets the current block as a new random block.
currentBlock = new Block();
}

// Sets the next block as a new random block.
nextBlock = new Block();
}

/// <summary>
/// Private method that moves the current block to the game pile.
/// While moving the block to the pile, it checks if there are complete lines, and count them, in
/// order to update the score, the lines and the level. It also checks for game over.
/// </summary>
private void MoveBlockToPile()
{
// Runs through the current block Width.
for(int i = 0; i < currentBlock.Width; i++)
{
// Runs through the current block Height.
for(int j = 0; j < currentBlock.Height; j++)
{
// Converts the current brick position the a playing field position.
int fx, fy;
fx = currentBlock.Left + i;
fy = currentBlock.Top + j;
// Checks if the current brick is solid.
if (currentBlock.Shape[i, j].Filled == true)
{
// The current brick is solid.
// Moves the current brick to the pile.
pile[fx, fy].Filled = true;
pile[fx, fy].BrickImage = currentBlock.Shape[i, j].BrickImage;
}
}
}

// Checks for complete lines.
CheckForLines();

// Checks for game over.
CheckForGameOver();
}

/// <summary>
/// Private method that checks the pile for complete lines.
/// </summary>
/// <returns>The number of found lines.</returns>
private int CheckForLines()
{
// Creates a variable that will hold the number of lines found.
int numLines = 0;
// Creates a variable that will hold the number of the complete lines found.
int[] completeLines = new int[PlayingFieldHeight];

// Runs through the playing field lines.
for (int j = PlayingFieldHeight; j > 0; j--)
{
// Checks if there is a complete line.
bool fullLine = true;

for (int i = 0; i < PlayingFieldWidth; i++)
{
if (pile[i, j].Filled == false)
{
fullLine = false;
break;
}
}

// Checks if there was a complete line.
if (fullLine)
{
// There was a complete line.
// Increases the number of complete lines found.
numLines++;
// Pauses the game so no block will come down while clearing the complete line.
this.GameState = GameState.Paused;
// Holds the number of the complete line found.
completeLines[numLines] = j;
// Sets the game state to "Running" again, to release the game.
this.GameState = GameState.Running;
}
}

// Checks if there were any complete lines.
if (numLines > 0)
{
// There were complete lines.
// Runs through all the complete lines, and clears them.
for(int i = 1; i <= numLines; i++)
{
// Clear a complete line.
ClearLine((completeLines[i] + (i - 1)));
}
// Updates the game score, lines and level.
score += 5 * (numLines * (numLines + 1));
lines += numLines;
level = (short)((lines / LevelEveryLines) + startLevel);
}

// Returns the number of complete lines.
return numLines;
}

/// <summary>
/// Private method that checks the pile for game over.
/// </summary>
private void CheckForGameOver()
{
// Checks if the top of the current block is on the top of the pile.
if (currentBlock.Top == 1)
{
// Current block is on the top the the pile.
// Sets the game state to "Over".
this.GameState = GameState.Over;
}
}

/// <summary>
/// Private method that clears a line from the pile.
/// </summary>
/// <param name="lineNumber">The number of the line to be cleared.</param>
private void ClearLine(int lineNumber)
{
// Runs through all the lines, from the line to be cleared up.
for (int j = lineNumber; j > 0; j--)
{
// Runs through all the bricks in one line.
for (int i = 0; i < PlayingFieldWidth; i++)
{
// Move the current brick down.
pile[i, j] = pile[i, (j - 1)];
}
}

// Runs through the top line bricks.
for (int i = 0; i < PlayingFieldWidth; i++)
{
// Sets the current brick to empty.
pile[i, 0].Filled = false;
}
}
}
}

这是其中之一最重要的部分,要全部代码给我发邮件
[email protected]

㈢ 如何用java编写出一个俄罗斯方块小程序

packagecom.test.games;

importjava.awt.Graphics;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.awt.event.KeyEvent;
importjava.awt.event.KeyListener;

importjavax.swing.JFrame;
importjavax.swing.JMenu;
importjavax.swing.JMenuBar;
importjavax.swing.JMenuItem;
importjavax.swing.JOptionPane;
importjavax.swing.JPanel;
importjavax.swing.Timer;

{
	publicTetris(){
		Tetrisbloka=newTetrisblok();
		addKeyListener(a);
		add(a);
	}

	publicstaticvoidmain(String[]args){
		Tetrisframe=newTetris();
		JMenuBarmenu=newJMenuBar();
		frame.setJMenuBar(menu);
		JMenugame=newJMenu("游戏");
		JMenuItemnewgame=game.add("新游戏");
		JMenuItempause=game.add("暂停");
		JMenuItemgoon=game.add("继续");
		JMenuItemexit=game.add("退出");
		JMenuhelp=newJMenu("帮助");
		JMenuItemabout=help.add("关于");
		menu.add(game);
		menu.add(help);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(220,275);
		frame.setTitle("Tetris内测版");
		//frame.setUndecorated(true);
		frame.setVisible(true);
		frame.setResizable(false);

	}
}

//创建一个俄罗斯方块类
{

	//blockType代表方块类型
	//turnState代表方块状态
	privateintblockType;
	privateintscore=0;

	privateintturnState;

	privateintx;

	privateinty;

	privateinti=0;

	intj=0;
	intflag=0;
	//定义已经放下的方块x=0-11,y=0-21;
	int[][]map=newint[13][23];

	//方块的形状第一组代表方块类型有S、Z、L、J、I、O、T7种第二组代表旋转几次第三四组为方块矩阵
	privatefinalintshapes[][][]=newint[][][]{
			//i
			{{0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0},{0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0},
					{0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0},
					{0,1,0,0,0,1,0,0,0,1,0,0,0,1,0,0}},
			//s
			{{0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0},{1,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0},
					{0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0},
					{1,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0}},
			//z
			{{1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0},{0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0},
					{1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0},
					{0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0}},
			//j
			{{0,1,0,0,0,1,0,0,1,1,0,0,0,0,0,0},{1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0},
					{1,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0},
					{1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0}},
			//o
			{{1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0},{1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0},
					{1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0},
					{1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0}},
			//l
			{{1,0,0,0,1,0,0,0,1,1,0,0,0,0,0,0},{1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0},
					{1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0},
					{0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,0}},
			//t
			{{0,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0},{0,1,0,0,1,1,0,0,0,1,0,0,0,0,0,0},
					{1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0},
					{0,1,0,0,0,1,1,0,0,1,0,0,0,0,0,0}}};

	//生成新方块的方法
	publicvoidnewblock(){
		blockType=(int)(Math.random()*1000)%7;
		turnState=(int)(Math.random()*1000)%4;
		x=4;
		y=0;
		if(gameover(x,y)==1){

			newmap();
			drawwall();
			score=0;
			JOptionPane.showMessageDialog(null,"GAMEOVER");
		}
	}

	//画围墙
	publicvoiddrawwall(){
		for(i=0;i<12;i++){
			map[i][21]=2;
		}
		for(j=0;j<22;j++){
			map[11][j]=2;
			map[0][j]=2;
		}
	}

	//初始化地图
	publicvoidnewmap(){
		for(i=0;i<12;i++){
			for(j=0;j<22;j++){
				map[i][j]=0;
			}
		}
	}

	//初始化构造方法
	Tetrisblok(){
		newblock();
		newmap();
		drawwall();
		Timertimer=newTimer(1000,newTimerListener());
		timer.start();
	}

	//旋转的方法
	publicvoidturn(){
		inttempturnState=turnState;
		turnState=(turnState+1)%4;
		if(blow(x,y,blockType,turnState)==1){
		}
		if(blow(x,y,blockType,turnState)==0){
			turnState=tempturnState;
		}
		repaint();
	}

	//左移的方法
	publicvoidleft(){
		if(blow(x-1,y,blockType,turnState)==1){
			x=x-1;
		}
		;
		repaint();
	}

	//右移的方法
	publicvoidright(){
		if(blow(x+1,y,blockType,turnState)==1){
			x=x+1;
		}
		;
		repaint();
	}

	//下落的方法
	publicvoiddown(){
		if(blow(x,y+1,blockType,turnState)==1){
			y=y+1;
			delline();
		}
		;
		if(blow(x,y+1,blockType,turnState)==0){
			add(x,y,blockType,turnState);
			newblock();
			delline();
		}
		;
		repaint();
	}

	//是否合法的方法
	publicintblow(intx,inty,intblockType,intturnState){
		for(inta=0;a<4;a++){
			for(intb=0;b<4;b++){
				if(((shapes[blockType][turnState][a*4+b]==1)&&(map[x+b+1][y+a]==1))
						||((shapes[blockType][turnState][a*4+b]==1)&&(map[x+b+1][y+a]==2))){

					return0;
				}
			}
		}
		return1;
	}

	//消行的方法
	publicvoiddelline(){
		intc=0;
		for(intb=0;b<22;b++){
			for(inta=0;a<12;a++){
				if(map[a][b]==1){

					c=c+1;
					if(c==10){
						score+=10;
						for(intd=b;d>0;d--){
							for(inte=0;e<11;e++){
								map[e][d]=map[e][d-1];

							}
						}
					}
				}
			}
			c=0;
		}
	}

	//判断你挂的方法
	publicintgameover(intx,inty){
		if(blow(x,y,blockType,turnState)==0){
			return1;
		}
		return0;
	}

	//把当前添加map
	publicvoidadd(intx,inty,intblockType,intturnState){
		intj=0;
		for(inta=0;a<4;a++){
			for(intb=0;b<4;b++){
				if(map[x+b+1][y+a]==0){
					map[x+b+1][y+a]=shapes[blockType][turnState][j];
				}
				;
				j++;
			}
		}
	}

	//画方块的的方法
	publicvoidpaintComponent(Graphicsg){
		super.paintComponent(g);
		//画当前方块
		for(j=0;j<16;j++){
			if(shapes[blockType][turnState][j]==1){
				g.fillRect((j%4+x+1)*10,(j/4+y)*10,10,10);
			}
		}
		//画已经固定的方块
		for(j=0;j<22;j++){
			for(i=0;i<12;i++){
				if(map[i][j]==1){
					g.fillRect(i*10,j*10,10,10);

				}
				if(map[i][j]==2){
					g.drawRect(i*10,j*10,10,10);

				}
			}
		}
		g.drawString("score="+score,125,10);
		g.drawString("抵制不良游戏，",125,110);
		g.drawString("拒绝盗版游戏。",125,170);
//		g.drawString("注意自我保护，",125,90);
//		g.drawString("谨防受骗上当。",125,110);
//		g.drawString("适度游戏益脑，",125,130);
//		g.drawString("沉迷游戏伤身。",125,150);
//		g.drawString("合理安排时间，",125,170);
//		g.drawString("享受健康生活。",125,190);
	}

	//键盘监听
	publicvoidkeyPressed(KeyEvente){
		switch(e.getKeyCode()){
		caseKeyEvent.VK_DOWN:
			down();
			break;
		caseKeyEvent.VK_UP:
			turn();
			break;
		caseKeyEvent.VK_RIGHT:
			right();
			break;
		caseKeyEvent.VK_LEFT:
			left();
			break;
		}

	}

	//无用
	publicvoidkeyReleased(KeyEvente){
	}

	//无用
	publicvoidkeyTyped(KeyEvente){
	}

	//定时器监听
	{
		publicvoidactionPerformed(ActionEvente){

			repaint();
			if(blow(x,y+1,blockType,turnState)==1){
				y=y+1;
				delline();
			}
			;
			if(blow(x,y+1,blockType,turnState)==0){

				if(flag==1){
					add(x,y,blockType,turnState);
					delline();
					newblock();
					flag=0;
				}
				flag=1;
			}
			;
		}
	}
}

㈣ 俄罗斯方块怎么做(要思想)

不要留空的

㈤ scratch 2.0俄罗斯方块如何编

那还得要了解你的scratch基础，如果你基础够好的话，我为你编一个，你就1比1复制就好了~(要会自定义方块，列表，变量，等90%积木块)

㈥ 一个简单的c语言写的俄罗斯方块程序

1、考虑怎么存储俄罗斯方块

俄罗斯方块的形状一共有19种类型，如果拿数组来表示的话，可能会比较会浪费空间(网上有很多实现代码)

考虑到每种方块形状的范围是4 *4的小方块，用 字模点阵的方式来存储，即设置一个4行4列的数组，元素置1即代表这个位置有小
方块，元素置0即代表这个位置无小方块，这个整个的4*4的数组组成俄罗斯方块的形状。
1000
1000
1100
0000
上述4*4来表示L形状的方块。
4*4 =16 bit 正好为short类型，所以每一个方块可以用一个short类型的数据来表示。

我们把俄罗斯方块点阵的数位存在rockArray中，我们可以事先把这19种方块的字模点阵自己转化成十六进制，然后在rockArray数组的初始化时赋值进去。
但是这种方式扩展性不好，每当有一种新方块时需要改动，
所以可以写一个配置文件来表示19种方块。(RockShape.ini)

@###@###@@######1234

从配置文件中读取方块的类型的代码在（Init.h的ReadRock函数中）在下面3中解释下代码如何实现

2如何画出方块

可以使用EasyX库来画出简单的图形，
EasyX库是在VC下实现TC的简单绘图功能的一个库，这个库很容易学会(直接 网络EasyX库，里面有详细的教程)

那么如何画出方块，方块已经存储到一个short类型中了
从short中读取出，可以用一个掩码mask = 1来与short的每个bit位相与，结果为1，则画出一个小方块；
函数声明：

void DisplayRock(int rockIdx, RockLocation_t* LocatePtr, bool displayed)1

参数1：表示在数组中的下标，取出short类型的方块表示数据
参数2：表示当前坐标，即画出方块的左上角的坐标x，y
参数3：true表示画出该方块，false 表示擦除该方块。

//方块在图形窗口中的位置(即定位4*4大块的左上角坐标) typedef struct LOCATE
{ int left; int top;
} RockLocation_t;123456

3如何实现同一种类型方块的翻转，

在按‘↑’时应该翻转同一种类型的方块，
比如下面的横杆和竖杆

@###@###@###@###@@@@############****1234567891011

可以假想成静态循环链表来实现这种方式
使同一种类型的方块循环起来，

用一个struct结构来表示一种方块

typedef struct ROCK
{ //用来表示方块的形状(每一个字节是8位，用每4位表示方块中的一行)
unsigned short rockShapeBits; int nextRockIndex; //下一个方块，在数组中的下标 } RockType;123456

定义一个RockType类型的数组来存储19种方块
RockType RockArray[19] = { (0, 0) };

当我们按“↑”时，把传入画方块函数DrawRock中的rockIndex变为当前方块结构体中的nextRockIndex即可。

简单解释下ReadRock函数的实现：当读取到空行的时候表示 一种方块已经读取完毕，当读取到****行时 表示同一种类型的方块读取完毕，具体看代码实现，代码中具体的注释

4、主要游戏实现的逻辑

贴一个预览图吧

注：上述预览图的游戏控制区和游戏显示区在Draw.h的DrawGameWindow()函数实现的

(1)在初始位置画出方块，在预览区画出下一次的方块
(2)方块有两种行为：响应键盘命令UserHitKeyBoard()，自由下落
如果敲击键盘了(w ,a ,s ,d, )空格表示暂停，如果在规定时间内没有敲击键盘的话，方块自由下落一个单位

if (kbhit()) //如果敲击键盘了 就处理按键
{
userHit = getch();
UserHitKeyBoard(userHit, &curRockIndex, &curRockLocation);
} //没有 就自动下移一个单位 :不能用else，因为可能按键不是上下左右
DWORD newtime = GetTickCount(); if (newtime - oldtime >= (unsigned int)(300) && moveAbled == TRUE)
{
oldtime = newtime;
DisplayRock(curRockIndex, &curRockLocation, false);
curRockLocation.top += ROCK_SQUARE_WIDTH; //下落一格
}1234567891011121314

(3)当方块落地(即不能下移了)时，判断是否满行，如果满行则消除，然后再判断游戏是否结束，游戏结束的话，直接退出游戏

判断满行：FullLine()函数，从最底下的一行开始判断，直到遇到一行空行，

while (count != xROCK_SQUARE_NUM ) //遇到空行 14
{
linefull = true; count = 0; for (int i = 1; i <= xROCK_SQUARE_NUM; ++i)
{ if (game_board[idx][i] == 0)
{
linefull = false; count++;
}
} if (linefull) //满行，消除当前行，更新分数
{
DelCurLine(idx);//消除满行
game_socres += 3;
UpdateSocres(game_socres);
idx++;//因为下面要减1
}
idx--;
}

(4)消除满行
将要删除的满行擦除：即将方块化成与背景色相同的，该代码为黑色
然后将上面的一行向下移，移一行删除一行，直到遇到空行
具体看代码的具体实现 game.h
void DelCurLine(int rowIdx)

(4)判断方块是否能移动
在game.h中实现

bool MoveAble(int rockIndex, RockLocation_t* currentLocatePtr, int f_direction)1

**比较当前位置的坐标(左上角)开始，能否放下rockIndex的方块。
注：f_direction为”↑”的话，则传入的rockIndex为下一个方块**

如果不能移动的话，给游戏game_board设置标记表示该位置被占有

//全局变量-游戏板的状态描述(即表示当前界面哪些位置有方块) //0表示没有，1表示有(多加了两行和两列，形成一个围墙，便于判断方块是否能够移动) int game_board[yROCK_SQUARE_NUM + 2][xROCK_SQUARE_NUM + 2] = { 0 };123

实现过程遇到的一些问题

(1)在快速下落的时候，可能方块会掉出围墙的范围内，
快速下落是使方块每次下落2个单位距离。
在判断不能下落时，使当前坐标的top即y减去一个单位的距离

(2)遇到多行满行时消除不了，
在判断满行时，循环找出满行，找出一个满行，就消除一行，然后继续判断是否满行，直到遇到空行

㈦ 怎么用vb制作俄罗斯方块游戏啊，简单点的。

visual basic继承了basic语言易学易用的特点，特别适合于初学者学习windows系统编程。随着21世纪信息社会的到来,计算机在人们的工作和生活中的深入,要求我们越来越多地与计算机打交道,为了使用户在繁忙的日程工作中得到放松,于是出现了各种各样的休闲软件,如聊天工具,游戏等等。于是我们小组着手设计开始一个这样的游戏软件。通过这学期来Visual Basic的学习，我初步掌握了Visual Basic语言的最基本的知识，于是在牛荣和李鹏等老师的指导下动手用Visual Basic编写俄罗斯方块游戏。
我们之所以选择开发俄罗斯方块游戏，无可争议，《俄罗斯方块》是有史以来最伟大的游戏之一。 在曾经发布过的所有游戏中，《俄罗斯方块》还被认为是仅有的一个能够真正吸引广泛人群的作品。谁能说清楚，迄今为止人们究竟花了多少万个小时在这个游戏上？也许这些时间本来可以被花在更具生产力的活动上。某些批评家也许会声称，《俄罗斯方块》要比过去二十年间出现的任何东西都要浪费人们的时间。至于我们，则要欣然提名它为GameSpot评选出的历史上最伟大游戏之一。
为了怀念经典，也为了能够给大多的计算机用户在工作之余找到一个休闲、娱乐的一个方式，我们小组开始着手用VB语言开发一个经典的俄罗斯方块游戏。
工程概况
2.1 项目名称
俄罗斯方块游戏
2.2 设计平台
VB 全称Visual Basic,它是以Basic语言作为其基本语言的一种可视化编程工具。
Vb是microsoft公司于1991年退出的windows应用程序开发工具visual意思是“可视化的”。在它刚推出来时，自身还存在一些缺陷，功能也相对少一些。但是经过多年的开发研究。最近microsoft公司又推出了VB6.0版本
VB6.0运行环境：硬件，要求486以上的处理器、16MB以上内存，50MB 以上的硬盘，cd-rom驱动器，鼠标。软件：要求windows 95以上版本。
2.3程序设计思想
游戏是用来给大家娱乐的，所以要能在使用的过程中给大家带来快乐，消除大家的疲劳，所以我们在游戏中添加了漂亮的场景和动听的音乐，设置了过关升级的功能，激发大家的娱乐激情。
从游戏的基本玩法出发，主要就是俄罗斯方块的形状和旋转，我们在设计中在一个图片框中构造了一个4*4的网状小块，由这些小块组合成新的形状，每四个小块连接在一起就可以构造出一种造型，因此我们总共设计了7中造型，每种造型又可以通过旋转而变化出2到4种形状，利用随机函数在一个欲览窗体中提前展示形状供用户参考，然后将展示的形状复制到游戏窗体中进行摆放，在游戏窗体中用户就可以使用键盘的方向键来控制方块的运动，然后利用递归语句对每一行进行判断，如果有某行的方块是满的，则消除这行的方块，并且使上面的方块自由下落，其中，方块向下的速度是有时钟控件控制的，在游戏中，用户也可以使用向下键加快下落速度，定义一个变量，对消除的函数进行记录，最后就可以得出用户的分数，用if 语句对分数判断，达到一定的积分就可以升级到下一个档次。
俄罗斯方块游戏设计的主要步骤为以下10个方面：
（1）游戏界面的设计。
（2）俄罗斯方块的造型。
（3）俄罗斯方块的旋转。
（4）俄罗斯方块的运动情况（包括向左，向右和向下）。
（5）俄罗斯方块的自动消行功能。
（6）游戏级别的自由选择。
（7）游戏速度的自由选择。
（8）游戏得分的计算。
（9）游戏菜单选项的设计及功能实现。
（10）游戏的背景音乐及特效。
2.4运用的控件和主要对象
我们在设计过程中主要用到的控件有:command控件，image控件，picture控件，label控件，timer控件，text控件，windows media player控件等等。
2.5主要实现的功能
我们开发的俄罗斯方块游戏，主要实现了以下几种功能：
1.可以灵活控制方块在图形框中运动。
2.游戏过程中方块可以自由旋转。
3.当某一行的方块排列满时，将自动将这一行方块消除，然后将上面所有方块向下移动，可以支持连续消行。
4.游戏前可以选择游戏的速度和游戏的等级，游戏速度既为方块下落速度，游戏等级为初始游戏时在基层随机生成一定行数的无规律方块，生成的行数由你来选择，每行至少产生5个以上的无规律方块，这样增加了游戏难度，对于游戏高手来说，无疑不是一个新的挑战。
5.游戏的得分支持积分，并且按照公式：
得分 = 原来分数+ 100 * (2 ^ 同时消除的行数-1)
这样，你同一时间消除的行数越多，你的得分也就越高，当游戏积分到了一定时可以自动升级，这个升级指速度升级。
6.游戏中提供了一个漂亮的场景和动听的音乐，给你带来无限激情。
2.6开发人员
由于这次课程设计所选的题目太复杂，而时间又比较紧张，指导老师建议和同学分工完成。我们小组成员包括组长孙磊周，副组长邹海星，此游戏由我们两个人共同开发而成。
正文
3.1游戏设计的具体实现
在我们两个人共同努力下，此次设计，终于能够圆满完成。由于时间的紧促，在设计中，也许会有一些考虑不周之处，但其功能已经能够满足大多用户的需求，相信假以时日，一定能做出一个更经典，更完美的俄罗斯方块游戏，下面我们将对每一步的具体如何实现展示给大家。
3.1.1游戏界面的设计和背景音乐及特效的实现
俄罗斯方块游戏主要由两个界面构成，登陆界面和开始游戏界面，在登陆界面中我们可以首先看到圣诞节的晚上飘梅花的场景，梅花从窗体顶部做函数曲线的下落运动，在窗体中定义一个Image控件组，在通用中定义梅花X坐标变量动态数组，Y坐标变量动态数组，步距X的变量动态数组，步距Y的变量动态数组，以及振幅变量动态数组。然后在窗体form_load中可以定义梅花的数量，利用随机函数产生随机的梅花坐标，步距和振幅，Image控件在运行时候就调用梅花图片，Image控件就可以由时钟控件控制下落速度，可以自由调节，梅花按snow(i).Left = xp(i) + am(i) * Sin(dx(i))函数在做纵向的正玄函数轨迹运动，竖直方向上为自由下落运动，，有am(i)来控制梅花的左右移动振幅。因此，我们就可以看到一个梅花在空中自由飘舞的画面了。
背景画面是用photoshop软件处理的漂亮图案，原本画面中的动画效果都是由Image控件制作的，还有点击进入游戏的按钮是由Label控件实现的，因为Image控件没有置前置后功能，不能将下雪的场景体现完整性，所以将这些图案全部放在背景上，不影响雪花飘落的效果，当点击画面的时候一样可以进入游戏界面。
游戏的背景音乐是由一段代码调用系统播放器Windows Player播放背景音乐，由于本次设计主要是针对游戏如何设计的，所以在这里就不对播放背景音乐的功能做介绍了。
3.1.2俄罗斯方块的造型
相信朋友们都玩过俄罗斯方块，对这个游戏的玩法和方块形状都比较熟悉。我们这个游戏只选择了最基本的7中造型，包括长条型，正方型，正S型，反S型，正7型，反7型，T型。如果需要我们可以添加更多的造型。将游戏界面的游戏区图片框分割成10*20的小块，每个小块放置一个command控件，预览区图片框按同样比例分割成4*4的小块，同样有command控件构成，我们可以把预览区图片框看作是从游戏区图片框中选取的一个部分，游戏区的小方块编号和欲览区编号如下图：
0 1 2 3 4 5 6 7 8 9
… … … … … … … … … …
… … … … … … … … … …
90 91 92 93 94 95 96 97 98 99
3 4 5 6
13 14 15 16
23 24 25 26
33 34 35 36
游戏区编号 欲览区编号
利用Select将方块的7中造型列出，比如长条型的设计，在欲览区中分别有3.4.5.6和5.15.25.35四个方块构成两中形态，用数组为：
m(0) = 3: m(1) = 4: m(2) = 5: m(3) = 6: situation2 = 0
m(0) = 5: m(1) = 15: m(2) = 25: m(3) = 35: situation2 = 1
将它的形状编号为0和1，在后面方便调用，其他的方块造型同样的方法。
3.1.3俄罗斯方块的旋转
俄罗斯方块的旋转主要将方块的位置加以变换得到的，例如上述范例，长条型有两中样式，根据小方块的编号变动来实现整个造型的旋转，比如：
If n(0) - 18 >= 2 And n(3) + 9 <= 198 Then
If cmdfang(n(0) - 18).Visible = False And _
cmdfang(n(1) - 9).Visible = False And _
cmdfang(n(3) + 9).Visible = False Then
hidefang 0
n(0) = n(0) - 18
n(1) = n(1) - 9
n(3) = n(3) + 9
showfang 0
situation = 1
End If
End If
方块的造型在旋转的时候存在一个公式，当然首先要判断是否满足旋转的要求，以上是一个长条型由横着变成竖立状态的旋转，我们以它的造型中的第三个小方块n(3)为中心旋转，这样，在开始运动的时候，长条形要发生旋转最少要运动到第三行，才能由横着变成竖立状态，游戏区图形框中第三行的第一个方块的编号为20，所以长条造型的第一个小方块的编号n(0)必须要大于20。同样，长条型方块在下落到底部的时候也有限制。如果长条下落到最后一行也将无法由横着变成竖立状态。
3.1.4如何实现方块的运动和自动消除满行的方块
我们的这个俄罗斯方块游戏主要是利用command控件的visible属性完成效果的，其实在游戏区图形框可以看成是由许多的command小方块组成，方块运动的过程就是造型里方块显示或者隐藏，就像现在的霓虹灯效果一样，由时钟控件控制visible属性改变的速度，上一层的消失，下一层的显示，这样，从视觉效果可以看到方块的下落运动效果。
方块在下落的过程中会自动判断每一行方块的visible属性，如果全部为true时，就会将这一行小方块的visible属性全部变成false，在将上面的小方块向下移动，利用for语句进行循环判断，将所有这样情况的行改变小方块visible属性。当有多行同时出现这样情况时使用递归调用，实现连续消行。具体程序代码如下：
For i = 190 To 10 Step -10
If cmdfang(i).Visible = True And _
cmdfang(i + 1).Visible = True And _
cmdfang(i + 2).Visible = True And _
cmdfang(i + 3).Visible = True And _
cmdfang(i + 4).Visible = True And _
cmdfang(i + 5).Visible = True And _
cmdfang(i + 6).Visible = True And _
cmdfang(i + 7).Visible = True And _
cmdfang(i + 8).Visible = True And _
cmdfang(i + 9).Visible = True Then
For j = i + 4 To i Step -1
t = 1
cmdfang(j).Visible = False
cmdfang(2 * i + 9 - j).Visible = False
For k = 1 To 4000
DoEvents
Next
t = 0
Next
linenum = linenum + 1
For j = i - 1 To 0 Step -1
If cmdfang(j).Visible = True Then
cmdfang(j).Visible = False
cmdfang(j + 10).Visible = True
End If
Next
clearline '为了实现连消数行，这里使用递归调用
End If
Next
3.1.5游戏速度和游戏级别自由选择
游戏速度的自由选择无非就是改变时钟控件的频率，我们在菜单中添加了选择速度的功能，还有添加了考验功能，将欲览窗中的方块造型隐藏，给玩家提高了难度，如果你不愿意接受考验也可以点击显示还原成原来状态。
游戏级别的自由选择是让用户选择游戏开始时候，游戏区底部出现一定行数的随机方块，同样给玩家增加了难度，功能代码如下：
For i = 19 To 20 - Val(txthard.Text) Step -1
For j = i * 10 To i * 10 + 9
If Rnd >= 0.5 Then cmdfang(j).Visible = True
Next
Next
可以根据你选择的难度系数在底层的每一行随机产生超过半数（即5个以上）以上的小方块，这样适合喜欢高难度的玩家。
3.1.6游戏得分的计算和游戏菜单的编辑
游戏得分的计算主要是根据消除的行数来决定的，当然每一次同时消除的行数不一样，每一行的得分也不一样，如果你每次消除的行数为1，则最后得分是100分，如果同时消除2行，则最后得分是300分，同时消除3行，得分为700分，同时消除4行，得分为1500分，这由公式：得分 = 原来分数+ 100 * (2 ^ 同时消除的行数-1)。
游戏的编辑，读者可以参照下面的功能介绍。
3.2 游戏功能的介绍
文件-------开始：开始游戏。
继续：继续游戏。
暂停：暂时停止游戏，点击继续的时候可以继续游戏。
退出：退出游戏。
设置-------选择游戏级别。
选择游戏速度。
考验-------显示：显示欲览去方块。
隐藏：隐藏欲览去方块。
帮助-------操作提示以及版本信息和作者资料。

用户界面具体如图：

图—登陆界面 图—游戏界面

图—菜单编辑界面 图—游戏帮助界面
有关说明
经过两个多星期的设计和开发，俄罗斯方块游戏已经成功。其功能基本符合用户需求，能够完成游戏的控制，方块的变换以及消层等功能。并提供游戏设置，对于一些技术性比较过硬的玩家，可以调游戏级别、以及游戏速度，使得玩家能够充分的发挥竞技游戏的特色，可以不断的挑战自我，挑战极限。
4.1游戏设计中的不足之处
但是由于课程设计时间较短，所以该游戏还有许多不尽如人意的地方，比如方块类型太少，退出游戏不能存储进度等多方面问题。这些都有待进一步改善，我们在游戏中还可以更换背景音乐，以适合不同的玩家，在每通过一关可以给玩家播放一段flash，吸引玩家去挑战极限，不断提高玩家的兴趣，相信在以后的制作过程中我们将给大家带来一个更新功能更全面的游戏。
4.2VB与C语言之间的不同之处
我们这个小游戏也可以用C语言来实现，在程序的编程上没有VB语言方便实用，C语言和VB语言之间存在很多的共同点，虽然语法方面有点差异，但是在编程思路上完全一样，VB能够实现很多C#不能做到的功能，如When语句、Optional参数、局部Static变量、对象实例访问静态方法、Handles绑定事件、On Error处理异常、Object直接后期绑定等等。VB和C#语言，编译出来的是同样的CIL，但为什么VB支持很多有趣的特性呢。我们一起来探究一下。
4.21局部静态变量
VB支持用Static关键字声明局部变量，这样在过程结束的时候可以保持变量的数值：
Public Sub Test1()
Static i As Integer
i += 1 '实现一个过程调用计数器
End Sub
我们实现了一个简单的过程计数器。每调用一次Test，计数器的数值就增加1。其实还有很多情况我们希望保持变量的数值。而C#的static是不能用在过程内部的。因此要实现过程计数器，我们必须声明一个类级别的变量。这样做明显不如VB好。因为无法防止其他过程修改计数器变量。这就和对象封装一个道理，本来应该是一个方法的局部变量，现在我要被迫把它独立出来，显然是不好的设计。那么VB是怎么生成局部静态变量的呢？将上述代码返汇编，我们可以清楚地看到在VB生成的CIL中，i不是作为局部变量，而是作为类的Field出现的： .field private specialname int32 $STATIC$Test1$2001$i
也就是说，i被改名作为一个类的字段，但被冠以specialname。在代码中试图访问$STATIC$Test1$2001$i是不可能的，因为它不是一个有效的标识符。但是在IL中，将这个变量加一的代码却与一般的类字段完全一样，是通过ldfld加载的。我觉得这个方法十分聪明，把静态变量变成生命周期一样的类字段，但是又由编译器来控制访问的权限，让它成为一个局部变量。同时也解释了VB为什么要用两个不同的关键字来声明静态变量——Static和Shared。由于局部静态变量的实质是类的字段，所以它和真正的局部变量还是有所不同的。比如在多线程条件下，对局部静态变量的访问就和访问字段相同。
4.2.2Handles和WithEvents
VB除了可以用C#那样的方法来处理事件响应以外，还有从VB5继承下来的独特的事件处理方式——WithEvents。
我喜欢称这种事件处理方式为静态的事件处理，书写响应事件的方法时就已经决定该方法响应的是哪一个事件，而C#则是在代码中绑定事件的。VB中WithEvents静态方法是非常有用的，它可以显着增强代码可读性，同时也让VB.net中的事件处理非常方便，不像C#那样离开了窗体设计器就必须手工绑定事件。
4.2.3类型转换运算符
在Visual Basic 2005中将加入一个新的运算符——TryCast，相当于C#的as运算符。我一直希望VB有这样一个运算符。VB目前的类型转换运算符主要有CType和DirectCast。他们的用法几乎一样。我详细比较了一下这两个运算符，得出以下结论：
1.在转换成引用类型时，两者没有什么区别，都是直接调用castclass指令，除非重载了类型转换运算符CType。DirectCast运算符是不能重载的。
2.转换成值类型时，CType会调用VB指定的类型转换函数（如果有的话），比如将String转换为Int32时，就会自动调用。
4.2.4默认属性和属性参数
在原先的VB6里，有一项奇特的功能——默认属性。在VB6中，对象的名称可以直接表示该对象的默认属性。
4.2.5可选参数和按名传递
VB从4.0开始支持“可选参数”这一特性。就是说，函数或子程序的参数有些是可选的，调用的时候可以不输入。其实VB从1.0开始就有一些函数带有可选参数，只不过到了4.0才让用户自己开发这样的过程。在VB4里，可选参数可以不带默认值，而在VB里，如果使用可选参数，则必须带有默认值。在调用的时候，VB若发现参数被省略，则自动读取.param部分的默认值，并显式传递给过程。这一部分完全由编译器处理，而且没有任何性能损失，和手工传递所有参数是完全一样的。至于按名传递，VB会自动调整参数的顺序，其结果与传统方式的传递也没有任何的不同。这说明我们可以放心地使用这项便利。而且带有可选参数的过程拿到C#中，顶多变成不可选参数，也不会造成什么其他的麻烦。
PS.很多COM组件都使用了默认参数，而且有些过程的参数列表非常长，在VB里可以轻松地处理它们，而在C#中经常让开发者传参数传到吐血。
4.2.6在经过对比之后可得以下一个结论：
1.目前的主流编程语言没有简单的，如果你想学精通的话。
2.VB的门槛比较低，编程思想较容易接受。
3.学习C不能短期内见到成效。
4.据用户调查69%的考生觉得VB更容易接受

致谢
在本次课程设计中，我从指导老师牛荣和李鹏身上学到了很多东西。老师认真负责的工作态度，严谨的治学精神和深厚的理论水平都使我收益匪浅。他无论在理论上还是在实践中，都给与我很大的帮助，使我得到不少的提高这对于我以后的工作和学习都有一种巨大的帮助，感谢他耐心的辅导。
另外，在游戏开发过程中化希耀老师和杜义君老师也给于我们很大的帮助，帮助解决了不少的难点，使得游戏能及时开发完成，还有所有的同学同样给与我不少帮助，这里一并表示感。

参考文献：
[1]Vsual Basic 程序设计教程 作者：龚沛曾，陆慰民，杨志强 高等教育出版社出版
[2]Vsual Basic 6.0程序设计 作者：刘新民，蔡琼，白糠生 清华大学出版社出版
[3]80例上手 VB6 编程 作者：唐凯军，汤惠莉 山东电子音像出版社
[4]Vsual Basic 实例教程 作者：卢毅 科学出版社出版
[5]Vsual Basic 经典范例50讲 作者：赵欣胜，亢慧娟，刘晟宏 科学出版社出版

㈧ 俄罗斯方块的来源

俄罗斯方块--可能是这个世界上最出色，最多人玩过，普及率最高的游戏了。但你可知否，在这个游戏的背后，却有着一段复杂的版权之争的历史！

你一定玩过俄罗斯方块吧！对该游戏，你一定会有自己的观点和看法，在了解过俄罗斯方块这款曲折的历史后，你是否有自己的说话要发表呢？

俄罗斯方块操作简单，难度却不低。作为家喻户晓老少皆宜的大众游戏，时至今日玩游戏的人（以及许多不怎么玩游戏的人）中谁要是不知道的话可真所谓是火星上的熊猫了。但是，谁知道这么优秀的娱乐工具，出自哪位神人之手呢？

顾名思义，俄罗斯方块自然是俄罗斯人发明的。这位伟人叫做阿列克谢·帕基特诺夫（Alexey Patnov） 。标题画面中玩GB的大胡子就是他。看不清楚没关系，下面来一张近距离接触的图片：

其实他还开发了许多优秀的游戏。和许多大牌厂商合作过。这是他的作品年表：

Project Gotham Racing 2 (2003), Microsoft
Fuzion Frenzy (2001), Microsoft
Rampage Puzzle Attack (2001), Midway Games
Tetris Worlds (2001), THQ Inc.
Microsoft Puzzle Collection Entertainment Pack (2000), Swing! Entertainment Media AG
The Next Tetris: Online Edition (2000), Crave Entertainment, Inc.
The Next Tetris (1999), Hasbro Interactive
Pandora's Box (1999), Microsoft
Knight Moves (1996), Spectrum Holobyte, Inc.
Breakthru! (1994), Spectrum Holobyte, Inc.
El-Fish (1993), Maxis Software Inc.
Tetris Pro (1993), 2000 A.D.
Yoshi's Cookie (1993), Nintendo
Super Tetris (1991), Spectrum Holobyte, Inc.
Faces (1990), Spectrum Holobyte, Inc.
Pipe Dream (1990), Bullet-Proof Software, LucasArts
Welltris (1989), Spectrum Holobyte, Inc.
Tetris (1988),
Tetris (original) (1986)

然而，很少有人知道，这个着名的游戏在80年代曾经在法律界掀起轩然大波，那就是着名的俄罗斯方块产权之争。这次产权争夺，几家欢喜，几家哀愁，几家公司倒闭，几家公司赚钱，其中的是是非非，一言难尽。

1985年6月
工作于莫斯科科学计算机中心的阿列克谢·帕基特诺夫在玩过一个拼图游戏之后受到启发，从而制作了一个以Electronica 60（一种计算机）为平台的俄罗斯方块的游戏。后来经瓦丁·格拉西莫夫（Vadim Gerasimov）移植到PC上，并且在莫斯科的电脑界传播。帕基特诺夫因此开始小有名气。

1986年7月
PC版俄罗斯方块在匈牙利的布达佩斯被当地的一群电脑专家移植到了Apple II 和 Commodore 64 上，这些版本的软件引起了当时英国一个叫Andromeda的游戏公司经理罗伯特·斯坦恩（Robert Stein）的注意，他向帕基特诺夫以及匈牙利的电脑专家们收购了俄罗斯方块的版权，并且在买到版权之前把它们倒手卖给了英国的Mirrorsoft （注意不是Microsoft！） 以及美国的Spectrum Holobyte。（什么人……）

1986年11月
斯坦恩和帕基特诺夫经过谈判，就版权收购问题未取得成果。斯坦恩甚至直接飞到莫斯科和帕基特诺夫面谈，但是空手而归。由于俄罗斯人对于已经在西方兴起的电子游戏产业知道不多，斯坦恩决定窃取Tetris的版权，于是他放出谣言说这是匈牙利人开发的游戏。

与此同时，PC版的俄罗斯方块已经由英国的Mirrorsoft出品并且在欧洲销售，受到当时人们的极大关注。不仅仅因为这个游戏好玩，而且这是“第一个来自铁幕国家的游戏。”当时的游戏宣传海报上有浓郁的冷战色彩，比如战争画面，加加林太空飞行等。而斯坦恩仍然没有正式合法的版权。

1987年6月
斯坦恩最终取得了在IBM-PC及其兼容机上的Tetris的版权，版权机种包括“其他任何电脑系统”。但是，他没有和苏联方面签署协议，也就是说，这个版权是不完全的。（译者注： 这个“其他任何电脑系统”在原文中的描述是"any other computer system"，这种说法在当时看来也很不严密，从而为后来的产权之争埋下了伏笔）

1988年1月
Tetris在电脑平台的热销，一时造成“洛阳纸贵”（伦敦磁盘贵？？）的局面。而当CBS晚报采访了俄罗斯方块之父帕基特诺夫之后，斯坦恩盗窃版权的计划彻底泡汤了。（活该！）一个新的公司ELORG（Electronorgtechinca，苏联一家软件公司）开始和斯坦恩就游戏程序问题进行协商。ELORG的负责人亚历山大·阿列欣科（ Alexander Alexinko）知道斯坦恩虽然没有版权，但是会以手中的游戏开发程序为筹码威胁中断谈判。

1988年5月
经过几个月的争吵之后，筋疲力尽的斯坦恩终于和ELORG签定了PC俄罗斯方块版权的合约。当时的合约禁止开发街机版和掌机版的方块游戏，而电脑版的Tetris则成为当时最畅销的游戏。

1988年7月
斯坦恩与阿列欣科商谈开发街机版俄罗斯方块的问题。阿列欣科当时尚未从斯坦恩那里拿到一分钱的版权费，但是同时的Spectrum 和 Mirrorsoft已经开始向电子游戏商出售了俄罗斯方块的版权。Spectrum 将Tetris的游戏机和PC在日本的版权卖给了Bullet-Proof Software （FC和GB版俄罗斯方块的制作商），而Mirrorsoft则把它在日本和北美的版权卖给了美国的Atari。这样一来两家公司的矛盾就开始了。 1988年11月，BPS在FC上发行的俄罗斯方块（大家不很熟悉的俄罗斯方块1）在日本发售，销量达200万份。

1988年11月
随着GB的开发，NOA（任天堂美国分公司）的经理荒川实（任天堂山内溥老爷子的女婿）希望将Tetris做成GB上的游戏。于是他联系了BPS的总裁亨克·罗杰斯（Henk Rogers）， 罗杰斯再与斯坦恩联系的时候却吃了闭门羹。于是他直接去莫斯科购买版权。而斯坦恩觉察出风头，也乘飞机前往莫斯科；与此同时，Spectrum的负责人罗伯特·麦克斯韦（Robert Maxwell）的儿子凯文·麦克斯韦（Kevin Maxwell） 也在向莫斯科进发。就这样，三路人马几乎在同时赶到了冰天雪地的红色都市。

1989年2月21日
罗杰斯首先会见了ELORG的代表叶甫盖尼·别里科夫（Evgeni Belikov，和那个“装在套子里的人”同名）。他给帕基特诺夫等苏联人留下了深刻印象，并且签了手掌机方块游戏的版权。之后他向俄国人展示了FC版Tetris，这使别里科夫极为震惊。因为他并没有授予罗杰斯家用机的版权！罗杰斯则向他们说这是向TENGEN购买的版权，但是别里科夫也从来听说过TENGEN这个公司的名字。罗杰斯为了缓和尴尬的局面，将斯坦恩隐瞒的事实如数告诉了别里科夫，并且答应付给苏联方面更多支票作为已经卖出的FC版俄罗斯方块的版权费用。这时罗杰斯发现自己有机会买到Tetris全部机种的版权（但是当时还没买），虽然Atari会对他虎视耽耽，但是别忘了，他和BPS的背后还有任天堂这个大靠山给自己撑腰。

注意：罗伯特·斯坦恩原先所签的协议只是电脑版Tetris的版权，其他的版权并不是他的。

后来，斯坦恩和ELORG重新签署了协议。别里科夫强迫他重签的合约中修改的内容是：“电脑的定义：包含有中央处理器，监视器，磁盘驱动器，键盘和操作系统的机器”。而斯坦恩当时却没有仔细看这些定义。（这回轮到他犯混了……）后来他才意识到这是罗杰斯从自己手中抢走版权而耍的花招。但是为时已晚。第二天他被告知虽然签署的文件已经不能改后来，但是他还可以得到街机版Tetris的开发权。三天之后，他签下了街机版的协议。

1989年2月22日
凯文·麦克斯韦访问了ELORG。别里科夫拿出罗杰斯给他的FC游戏卡向他询问这件事情。麦克斯韦在卡带上看到了Mirrorsoft的名字后才想起他的公司已经把部分版权倒卖给了Atari。（糊涂人办糊涂事……）当他想继续谈街急和手掌机版权的问题的时候，却发现自己他能够签的，就只有除电脑，街机，家用机和掌机以外的协议了。（其实等于没有协议可签，除非他发明一种新的娱乐系统，比方说俄罗斯方块积木……）在糊涂之余这家伙灵机一动，告诉别里科夫说此卡带为盗版（汗……），然后也要签家用机的协议。

最后的结果是：凯文·麦克斯韦只带走一张白纸，罗伯特·斯坦恩带走了街机协议书。由于麦克斯韦声称所有的FC卡都是盗版，ELORG保留了家用机的版权，没卖给任何人。假如麦克斯韦想获得家用机版权的话，就必须出价比任天堂高才行。亨克·罗杰斯买到了掌机的版权，并且通知了荒川实。BPS就制作GB版Tetris向任天堂达成交易：这笔交易额高大500万-1000万美元。

1989年3月15日
亨克＆#8226;罗杰斯回到莫斯科，并且代表任天堂出巨资收购家用机版Tetris的版权。版权费的价格虽然没有向外界透露，但是这个数字将是Mirrorsoft永远拿不出来的。连荒川实和NOA的首席执行官霍华德·林肯（Howard Lincoln）都亲自前往苏联助阵。

1989年3月22日
ELORG和任天堂的家用机协议终于达成。任天堂方面坚持加入一款声明，在协议签定之后，如果和其他出现法律纠纷，苏联方面必须派人去美国的法庭上做证。实际上，这种法律上的争端将是不可避免的。据说ELORG仅仅得到的定金有300-500万美元之多。别里科夫向Mirrorsoft通知，说Mirrorsoft， Andromeda和Tengen都没有家用机的版权，现在版权都归任天堂所有。当天晚上任天堂和BPS的头目们在莫斯科酒店里举行了庆祝party。

（各位看明白了，现在家用机和掌机的版权已经被任天堂和BPS分别掌握在手中。无论是Atari还是Tengen都没有权利制作FC版的俄罗斯方块。）

1989年3月31日
霍华德·林肯 愉快（幸灾乐祸？）地向Atari发去最后通牒（传真），告诉他们立刻停止FC（NES）版的俄罗斯方块游戏。这使得Atari和麦克斯韦都十分震怒。他们以Tengen的名义回信说在4月7日那天他们就已经享有家用机俄罗斯方块的版权了。
1989年4月13日
Tengen撰写了一份申请书，要求拥有Tetris的“影音作品，源程序和游戏音乐”版权。但是申请书中并没有提及阿列克谢·帕基特诺夫和任天堂的游戏版权问题。（忽视了阿列克谢·帕基特诺夫真是个大错误！）

与此同时，麦克斯韦利用自己掌握的媒体势力，企图夺回Tetris的阵地。甚至搬出了苏联与英国政府，对俄罗斯方块版权问题进行干预。（好大的面子啊！）结果挑起了苏共（！）与ELORG之间的矛盾。甚至连戈尔巴乔夫都向麦克斯韦保证“以后不用担心日本公司的问题”。（汗……这位麦克斯韦果然不是善主……伟大的苏联政府都对俄罗斯方块关注起来了……）

在4月晚些时候，霍华德·林肯回到莫斯科的时候，发现ELORG已经在苏联政府的打压下抬不起头来，而就在那天半夜，NOA方面给他打电话，说Tengen已经起诉了任天堂。（山雨欲来风满楼啊……）

第二天，他面会了别里科夫，帕基特诺夫和其他几位ELORG的成员，以确保他们能够为任天堂的官司佐证。（这回合同里的条款可生效了）随后NOA立刻反诉Tengen，并且开始收集证据。

1989年5月17日
Tengen在USA Today上登载了大幅Tertis广告，虽然法庭大战已经迫在眉睫。

1989年6月
Tengen与任天堂的案子终于开庭审理。

论战主要围绕一个议题展开：NES（FC）究竟是电脑，还是电子游戏机。（大家不许笑，在法庭上这可是很严肃的话题）Atari认为NES是电脑系统，因为它拥有扩展机能，而且日本的Famicom也有网络功能存在。而任天堂的证据则更加切题：ELORG中的苏联人从来没有意向出售Tetris的家用机版权，而所谓的“电脑”的概念则早在和斯坦恩的协议中提到了。

1989年6月15日
法庭召开听证会，讨论关于任天堂和Tengen互相命令对方终止生产和销售各自的Tetris软件的行为。法官福恩·史密斯（Fern Smith）宣布Mirrorsoft 与 Spectrum Holobyte均没有家用机版权，因此他们提供给Tengen的权利也不能生效。任天堂的请求最后得到了许可。

1989年6月21日
Tengen版的俄罗斯方块全部撤下了货架，该游戏卡带的生产也被迫中止。数十万份软件留在包装盒里，封存在仓库中。

1989年7月
任天堂NES版Tetris在美国发售。全美销量大约300万。与此同时，和GB版Tetris捆绑销售的Game Boy席卷美国，美利坚大地上刮起一阵方块旋风。

关于Tetris的混战此时已经告一段落。而任天堂和Tengen之间的法庭纠纷则一直持续到1993年。

尾声

Atari Games仍然开发了街机版的Tetris，共卖出约2万台机器。近来Atari Games 被 Williams/WMS收购，而那些封存在仓库里的NES版Tetris的命运则没人知道。Tengen不能从其他途径把它们处理掉，所以估计这些软件都被销毁了。但是据说仍然有约10万份Tengen版的Tetris流入了市场。

我们今天在64合一等游戏D版卡里玩到的所谓“俄罗斯方块2”其实就是当年的Tengen版，平心而论，这一版的方块比BPS的版本要好玩许多。首先，这版的操作感和按键设定十分到位，AB分别是正转和反转，而BPS版是用十字键的下来转动，只支持一个方向，按A就直接“啪”地落下来，手感十分不爽；其次，它支持的二人对战，与电脑竞争和合作的模式也让人耳目一新。还有，音乐也是没的说。

罗伯特·斯坦恩，这个版权问题的始作俑者，在Tetris上总共只赚了25万美元。本来他可以挣多点钱的，但是Atari和Mirrorsoft在付他版税的时候没有给足。（应得的报应……）

Spectrum Holobyte 则需要和ELORG重新协商，以确保电脑版Tetris的版权。

罗伯特·麦克斯韦的媒体堡垒在混战中逐渐分崩离析，老麦克斯韦在做生意时做幕后黑手的事实也在调查中，而他却突然暴病身亡。（气死的……）Mirrorsoft 英国公司也惨淡地退出了历史舞台。

真正的大赢家是BPS的总裁亨克·罗杰斯，还有幕后的任天堂。俄罗斯方块究竟为任天堂赚了多少银子呢？答案恐怕永远说不清了。想一想吧，在美国GB都是和Tetris捆绑销售，以增加GB的出货量……然后因为Tetris买了GB的人还会买其他的GB卡……要是这么算起来的话，那利润简直就像滚雪球一样了。现在GB版的Tetris（Z版）总共生产了3000万张。（后来GB的俄罗斯方块又在SFC上出了复刻版，和《马里奥医生》一起出现在屏幕上，成为不朽之作。）

至于苏联方面，除了苏联政府，谁也没有从Tetris那里得到多少好处。苏联解体之后，原ELORG的人员都四散到了全国乃至世界各地，许多人继续开发游戏（比方说帕基特诺夫）。

阿列克谢·帕基特诺夫几乎没有从Tetris上赚到一分钱。ELORG本来打算给他Tetris的销售权，但是旋即取消了这笔交易。不过帕基特诺夫仍然为自己能够制作出这么一个世界闻名的优秀游戏而欣慰。他从科学院里得到一台286（当时在苏联可是了不起的电脑）作为奖励。而且分到了比同事们家宽敞明亮的房子。在1996年，亨克·罗杰斯支付给他一笔报酬（还算是个知恩图报的人），帕基特诺夫组建了Tetris Company LLC 公司，终于能够自己创作游戏，并且收取版权费了。

译者注：当年俄罗斯方块红遍世界的各个角落，一个本来是吃大锅饭的人在消极怠工的时候发明的娱乐工具成了造福全人类的宝贝，它的价值远远超越了开发这个软件时候的预想。Atari虽然在法庭上惨败，但是拜亚洲盗版商人所赐，Tengen版的俄罗斯方块已经在中国玩家心目中生根发芽，长叶开花，任天堂的正统Tetris在中国反而没人玩了。其实说了那么多，归根到底，平平淡淡才是真。有机会的话，下载一个FC的模拟器和一个64合一的经典ROM，回家体会一下俄罗斯方块的魅力吧……

㈨ 用c语言编写俄罗斯方块程序 求详解

1、用C语言绘制图形界面

EasyX图形库(http://www.easyx.cn)即TC的图形库在VC下的移植。

包含库#include <graphics.h>

先初始化图形窗口

initgraph(WINDOW_WIDTH, WINDOW_HIGH) ;WINDOW_WIDTH为窗口的宽带，WINDOW_HIGH为窗口的高度。

清空绘图设备

cleardevice();

设置画笔颜色

setcolor(RED) ;

设置线条风格

setlinestyle(PS_SOLID, NULL, 0);

画矩形

rectangle

还有画线、显示文字等函数，可以参照其帮助文档。

注意：由于我们用的是EasyX图形库，故源文件后缀要为.cpp，但其中内容都是C的语法。

2、存储表示出俄罗斯方块的形状

一、我们可以用编号，不同的编号代表不同的俄罗斯方块，根据编号把不同方块的画法写在代码中，这样19种

方块就得有19种相应的代码来描绘。而且这样扩展性不好，若以后设计了新的方块，则需要更改大量源代码。

二、我们很自然的想到可用字模点阵的形式来表示，即设置一个4行4列的数组，元素置1即代表这个位置有小

方块，元素置0即代表这个位置无小方块，这个整个的4*4的数组组成俄罗斯方块的形状。

1000

1000

1100

0000

我们把俄罗斯方块点阵的数位存在rockArray中，我们可以事先把这19种方块的字模点阵自己转化成十六进制，然后在rockArray数组的初始化时赋值进去。

但这样做未免有点太费力，且扩展性也不太好，若以后设计的新方块种类加入，要改变数组rockArray中的值。

我们可以考虑把所有俄罗斯方块的点阵存储在配置文件中，在程序初始化时读取文件，把这些点阵转换成unsigned int的变量存储在rockArray中。

这样，以后我们增添新的方块形状只需要在配置文件中增加新的点阵即可。

@###

@###

@@##

####（为使得看起来更醒目，我们用@表示1，用#表示0）

3、让图形动起来

在某位置处用函数DrawRock在屏幕上画出俄罗斯方块，然后再擦除掉(即用背景色在原位置处重绘一次方块)，最后在下落的下一个位置处用函数DrawRock在屏幕上画出俄罗斯方块，如此循环，中间用计时器间隔一段时间以控制下落的速度。

同理，按下屏幕的左右键也是如此，只是在按下键盘时把方块的位置重新计算了。

那么按下上方向键时，如何让方块翻转呢？

我们在配置文件中就把方块的顺时针翻转形态放在了一起：

@###

@###

@@##

####

@@@#

@###

####

####

@@##

#@##

#@##

####

##@#

@@@#

####

####

我们每按一次上方向键改变一次方块的形状即可。若一直按上键，形状应该是循环地翻滚。

我们想到了循环链表的数据结构可实现这个效果。

可是我们若把这些一种类的方块的各种形态串成循环链表形式，那么每次重新生成方块时我们就难以随机地生成方块了。

故还是得用数组来存储，但又要有循环链表的功能，于是我们想到了静态循环链表。

我们用结构体来作为一个方块在rockArray中的元素

typedef struct ROCK

{ //用来表示方块的形状(每一个字节是8位，用每4位表示方块中的一行)

unsigned int rockShapeBits ;

int nextRockIndex ; //下一个方块，在数组中的下标

} RockType ;

这样，当我们按下上方向键时，把传入函数DrawRock中的rockIndex变为当前方块结构体中的nextRockIndex即可。

㈩ 改写俄罗斯方块 C语言

我还是觉得E语言比较好用，国产的。
易语言是一个自主开发，适合国情，不同层次不同专业的人员易学易用的汉语编程语言。易语言降低了广大电脑用户编程的门槛，尤其是根本不懂英文或者英文了解很少的用户，可以通过使用本语言极其快速地进入Windows程序编写的大门。易语言汉语编程环境是一个支持基于汉语字、词编程的、全可视化的、跨主流操作系统平台的编程工具环境；拥有简、繁汉语以及英语、日语等多语种版本；能与常用的编程语言互相调用；具有充分利用API，COM、DLL、OCX组件，各种主流数据库，各种实用程序等多种资源的接口和支撑工具。易语言有自主开发的高质量编译器，中文源代码被直接编译为CPU指令，运行效率高，安全可信性高；拥有自己的数据库系统，且支持访问现有所有数据库；内置专用输入法，支持中文语句快速录入，完全解决了中文输入慢的问题；易语言除了支持界面设计的可视化，还支持程序流程的即时可视化；除了语句的中文化之外，易语言中还专门提供了适合中国国情的命令，如中文格式日期和时间处理、汉字发音处理、全半角字符处理、人民币金额的处理等；易语言综合采用了结构化、面向对象、组件、构架、集成化等多种先进技术，并在运行效率、性能价格比、全可视化支持、适应本地化需要、面向对象以及提供Windows，Linux上的运行平台等具有特色；现有各种支持库多达40多个，用户可以使用她来满足几乎所有的Windows编程需求，多媒体功能支持强大，完善的网络、端口通讯和互联网功能支持，网上与论坛上的学习资源众多。在易语言及其编译器的设计与实现、可视化汉语编程的构建、提供多种语言版本等方面具有创新。目前易语言已取得国家级鉴定，鉴定会专家一致认为：易语言在技术上居于国内领先地位，达到了当前同类产品的国际先进水平。
参考资料：http://www.dywt.com.cn/