如何生成俄羅斯方塊的邊界

『壹』 俄羅斯方塊游戲的 演算法實現（或者設計原理）

這是個優化問題，目標函數是最終得分，變數是每個方塊的得分，邊界條件就是樓主所說的「同等條件」。

解決該問題，需要知道「同等條件」，即總的方塊數以及每個方塊的形狀、出現順序。知道了這些條件，即可以編程實現演算法。

每個方塊含有各自的狀態,變換只需改變到下一個狀態就行了,完全可以用數組來實現(不用寫旋轉演算法了:)

比如:

/* 方塊類型為 ■■■■ */
char[2][4][4] B1={{{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}}};
含兩種狀態,每個狀態是一個4*4數組,為1表示實心,為0表示空心.
□■□□
□■□□
□■□□
□■□□

□□□□
■■■■
□□□□
□□□□

再詳細的就不用說了吧

『貳』 怎樣製作俄羅斯方塊

以下代碼粘貼在主場經第一禎，測試影片就看到了：
N = 20;//行數
WIDTH = 20;//方塊邊長
level = 0;//開始等級（下落速度）
ret = new Array();//當前出現的方塊
nextret = new Array();//下一個出現的方塊
bg = new Array();//背景數組
createEmptyMovieClip("panel", 1048575);//所有方塊都在此mc里
for (i = 0; i < 5; i++) {
//初始化方塊數組，2*5格式，前四行代表每個方塊的4個小塊的位置坐標，最後一行第一列是方塊形狀，第二列是方塊旋轉方向
ret.push(new Array(2));
nextret.push(new Array(2));
}
for (i = 0; i < 20; i++) {//初始化背景數組，10*20格式
bg.push(new Array(10));
}
X = Y = panel._x = panel._y = 0;//換為X、Y表示
function reach(x:Number, y:Number, ret:Object) {
//x、y為方塊位置，ret為方塊形狀，若方塊ret下落一格碰到邊界或者方塊返回1
var i:Number, j:Number, k:Number;
for (i = 0; i < N; i++) {
for (j = 0; j < 10; j++) {
if (bg[i][j] == 219) {
for (k = 0; k < 4; k++) {
if (x + ret[k][0] == j && y + ret[k][1] + 1 == i) {
return 1;
}
}
}
}
}
return 0;
}
function lrnotout(lorr:Number, a:Object) {
//lorr==-1代表a往左邊一格可行性的判斷，lorr==1代表右邊一格可行性的判斷，lorr==0代表a的位置合理性的判斷，出現不合理則返回0
var i:Number;
if (lorr == -1) {
for (i = 0; i < 4; i++) {
if (x + a[i][0] - 1 < 0 || reach(x - 1, y - 1, a)) {
return 0;
}
}
}
if (lorr == 1) {
for (i = 0; i < 4; i++) {
if (x + a[i][0] + 1 > 9 || reach(x - 1, y + 1, a)) {
return 0;
}
}
}
if (lorr == 0) {
for (i = 0; i < 4; i++) {
if (x + a[i][0] < 0 || x + a[i][0] > 9) {
return 0;
}
}
}
return 1;
}
function rv(a:Object, ret:Object) {
//方塊賦值，將a方塊賦值到ret方塊
var i:Number;
for (i = 0; i < 5; i++) {
ret[i][0] = a[i][0], ret[i][1] = a[i][1];
}
}
function rotate(ret:Object) {
//根據方塊ret最後一行（分別是形狀指示變數和旋轉方向變數）為ret的前四行賦以具體形狀值
switch (ret[4][0]) {
case 0 ://方形
a = [[1, 0], [2, 0], [1, 1], [2, 1], [0, 0]];
rv(a, ret);
return;
case 1 ://長形
switch (ret[4][1]) {
case 1 :
a = [[0, 0], [1, 0], [2, 0], [3, 0], [1, 0]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 0 :
a = [[1, 0], [1, 1], [1, 2], [1, 3], [1, 1]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
}
case 2 ://Z形
switch (ret[4][1]) {
case 1 :
a = [[0, 1], [1, 1], [1, 2], [2, 2], [2, 0]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 0 :
a = [[2, 0], [1, 1], [2, 1], [1, 2], [2, 1]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
}
case 3 ://反Z形
switch (ret[4][1]) {
case 1 :
a = [[1, 1], [2, 1], [0, 2], [1, 2], [3, 0]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 0 :
a = [[1, 0], [1, 1], [2, 1], [2, 2], [3, 1]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
}
case 4 ://T形
switch (ret[4][1]) {
case 3 :
a = [[1, 0], [0, 1], [1, 1], [2, 1], [4, 0]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 0 :
a = [[1, 0], [0, 1], [1, 1], [1, 2], [4, 1]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 1 :
a = [[0, 1], [1, 1], [2, 1], [1, 2], [4, 2]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 2 :
a = [[1, 0], [1, 1], [2, 1], [1, 2], [4, 3]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
}
case 5 ://倒L形
switch (ret[4][1]) {
case 3 :
a = [[1, 0], [2, 0], [1, 1], [1, 2], [5, 0]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 0 :
a = [[0, 1], [0, 2], [1, 2], [2, 2], [5, 1]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 1 :
a = [[2, 0], [2, 1], [1, 2], [2, 2], [5, 2]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 2 :
a = [[0, 1], [1, 1], [2, 1], [2, 2], [5, 3]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
}
case 6 ://L形
switch (ret[4][1]) {
case 3 :
a = [[1, 0], [2, 0], [2, 1], [2, 2], [5, 0]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 0 :
a = [[0, 1], [1, 1], [2, 1], [0, 2], [5, 1]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 1 :
a = [[1, 0], [1, 1], [1, 2], [2, 2], [5, 2]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
case 2 :
a = [[2, 1], [0, 2], [1, 2], [2, 2], [5, 3]];
if (lrnotout(0, a) && !reach(x, y - 1, a)) {
rv(a, ret);
}
return;
}
}
}
function generate(ret:Object) {//隨機產生方塊函數（可進一步修正）
ret[4][0] = Math.floor(Math.random() * 7);
ret[4][1] = Math.floor(Math.random() * 4);
rotate(ret);//完成方塊ret的具體形狀的賦值
}
function init() {//初始化背景、方塊、運動函數
var i:Number, j:Number;
for (i = 0; i < N; i++) {//初始化背景，邊界為219，其餘為' '
for (j = 0; j < 10; j++) {
if (i == N - 1) {
bg[i][j] = 219;
} else {
bg[i][j] = ' ';
}
}
}
for (i = 0; i < 5; i++) {//為當前方塊賦初值0
ret[i][0] = ret[i][1] = 0;
}
generate(ret);//產生當前方塊
generate(nextret);//產生下一個方塊
y = 0, x = 3, score = lines = 0, level=0;//當前位置坐標和計分系統初始化
_tetris.removeTextField();//如果從結束過的游戲恢復，刪除結束標志
display();//顯示畫面
frameflag = 0;//標示下落時間間隔
onEnterFrame = function () {
frameflag++;
if (10 - frameflag < level) {//根據等級level確定下落時間間隔
frameflag = 0;
go();//下落及判斷
}
};
}
function drawblock(a, b, c, d) {//繪制方塊的小塊
with (panel) {
beginFill(0x000FFF, 100);
lineStyle(1, 0xFF00FF);
moveTo(panel._x + a, panel._y + b);
lineTo(panel._x + c, panel._y + b);
lineTo(panel._x + c, panel._y + d);
lineTo(panel._x + a, panel._y + d);
lineTo(panel._x + a, panel._y + b);
endFill();
}
}
function erase() {//刪除一行方塊
var n:Number = 0, i:Number, j:Number, k:Number, l:Number;
for (i = 0; i < N - 1; i++) {
for (j = 0; j < 10; j++) {
if (bg[i][j] == ' ') {//如果該行有空，則開始判斷下一行
i++, j = -1;
if (i == N - 1) {//行N-1為底線，不判斷
break;
}
} else if (j == 9) {//判斷到該行最後一列都沒有空
for (k = i; k >= 1; k--) {//上方方塊下落
for (l = 0; l < 10; l++) {
bg[k][l] = bg[k - 1][l];
}
}
for (l = 0; l < 10; l++) {//刪除該行
bg[0][l] = ' ';
}
n++;//此次刪除行數變數增一
if ((lines + n) % 30 == 0) {//刪除行數總數到30的倍數則等級上升
level = (level + 1) % 10;
}
}
}
}
lines += n, score += (n * n + n) * 50;//總行數增n，計算得分
}
function display() {
//顯示函數，採用全部清除再重繪制的方法（因為這個程序本來是在Turbo C 2.0的文本環境下完成的）
var i:Number, j:Number;
panel.clear();
with (panel) {//畫邊界
lineStyle(1, 0x0000FF);
moveTo(panel._x, panel._y);
lineTo(panel._x + WIDTH * 10, panel._y);
lineTo(panel._x + WIDTH * 10, panel._y + WIDTH * (N - 1));
lineTo(panel._x, panel._y + WIDTH * (N - 1));
lineTo(panel._x, panel._y);
}
for (i = 0; i < 4; i++) {//當前方塊占據的地方賦值為邊界類型219
bg[y + ret[i][1]][x + ret[i][0]] = 219;
}
for (i = 0; i < N - 1; i++) {//繪制背景方塊
for (j = 0; j < 10; j++) {
if (bg[i][j] == 219) {
drawblock(j * WIDTH + X, i * WIDTH + Y, j * WIDTH + WIDTH + X, i * WIDTH + WIDTH + Y);
}
}
}
for (i = 0; i < 4; i++) {//繪制當前方塊
drawblock(nextret[i][0] * WIDTH + 14 * WIDTH + X, nextret[i][1] * WIDTH + 12 * WIDTH + Y, nextret[i][0] * WIDTH + WIDTH + 14 * WIDTH + X, nextret[i][1] * WIDTH + WIDTH + 12 * WIDTH + Y);
}
for (i = 0; i < 4; i++) {//當前方塊繪制完畢，重新將當前位置改為' '
bg[y + ret[i][1]][x + ret[i][0]] = ' ';
}
createTextField("_lvltxt", 1, 270, 100, 100, 20);//繪制計分系統
createTextField("_scrtxt", 2, 270, 130, 100, 20);
createTextField("_lnstxt", 3, 270, 160, 100, 20);
_lvltxt.text = "Level: " + level;
_scrtxt.text = "Score: " + score;
_lnstxt.text = "Lines: " + lines;
}
function go() {//下落函數
var sss:Number = reach(x, y, ret);//當前方塊下落一格是否碰到邊界或方塊
var ii:Number;
if (!sss) {
y++;//如果當前方塊下落一格沒有碰到邊界或方塊則下落一格
}
display();//重新繪制
if (sss) {//碰到邊界或方塊
score += 10;//得10分
display();//重新繪制
for (ii = 0; ii < 4; ii++) {//修改背景數組，將當前方塊的位置改為邊界類型
bg[y + ret[ii][1]][x + ret[ii][0]] = 219;
}
erase();//刪除行判斷及執行
rv(nextret, ret);//將下一個方塊賦值為當前方塊
y = 0, x = 3;//重置方塊位置
generate(nextret);//生成下一個方塊
display();//重新繪制
if (reach(x, y, ret)) {//如果下一格碰到方塊則游戲結束
createTextField("_tetris", 100000, WIDTH * 3.3, WIDTH * N / 3, 70, 20);
_tetris._x += 200;
_tetris._y += 50;
_tetris._xscale = 300;
_tetris._yscale = 300;
_tetris.background = true;
_tetris.text = "Game Over!";
onEnterFrame = function () {//停止下落
};
}
}
}
function key() {
if (Key.isDown(Key.UP)) {
rotate(ret);
display();
}
if (Key.isDown(Key.LEFT)) {
if (lrnotout(-1, ret)) {//左移可行性判斷
x--;
display();
}
}
if (Key.isDown(Key.RIGHT)) {
if (lrnotout(1, ret)) {//右移可行性判斷
x++;
display();
}
}
if (Key.isDown(Key.DOWN)) {//鍵盤控制下落
go();
}
if (Key.isDown(Key.SPACE)) {//一鍵下落到底
while (!reach(x, y, ret)) {
y++;
}
go();
}
if (Key.isDown(82)) { //重新開始游戲
init();
}
}
init();//初始化
setInterval(key, 80);//每個80毫秒執行一次鍵盤事件函數
createTextField("hinttxt",33324,200,20,300,50);
hinttxt.text="鍵盤鍵：上,下,左,右,R（reset）,空格";

『叄』 java俄羅斯方塊問題，我看俄羅斯方塊游戲，裡面的右上角可以看見下一個方塊是什麼，這是怎麼做出來的提示

你給的網址是一個MIDP俄羅斯方塊游戲的設計和實現
MIDP也就是對J2ME的開發，是一個手機游戲，你用Eclipse運行可能是沒有相應的java包支持，所以出錯了

『肆』 編程 俄羅斯方塊 C++ 如何輸出任意形狀和顏色的方塊

要任意就比較麻煩了。。。對於俄羅斯小游戲來說這樣做不值得，就事先指定好就行了。。

『伍』 做俄羅斯方塊的思路或演算法是什麼

掃雷、俄羅斯方塊這些小游戲不是為了開發游戲而開發，做這些項目只是為了鞏固你學的java se這部分的知識。比如說，你做俄羅斯方塊，你先得弄出個界面吧，這里就鞏固的你awt或者swing上的知識了。等等。
做項目不是一下子上來想好了所有的細節才開始寫的。你先把最先要寫的寫出來，比如得有界面，你就用awt或者swing上的知識做個界面，要做界面是不是要繼承Frame這個類啊。窗口裡面什麼也沒添加，先把窗口的大小，關閉等先寫出來。
然後再想想，有了界面了，你得有界面裡面的東西吧，比如一個方塊，那麼你就想想怎麼樣才能讓窗口裡面有個方塊呢？是不是想到把它畫出來啊，畫出來那麼就用到了paint方法，那你就看看這個方法具體是怎麼用的，可以查網路或者api，查到paint方法是自動調用的，所以你只需要把它重寫下就好。
....
做任何項目都是這樣，一步一步寫出來的，不是所有的細節你都考慮清楚了才開始寫的。所以不要怕，慢慢寫，等這個項目寫完了，你就慢慢知道怎麼開發一個項目了。
我們平時做開發也是先把最先能寫好的寫好，再慢慢填充後面想到的。
IO方面的知識很重要，你看見這兩個字母就能想到它是關於寫入和讀出操作的，那麼對什麼寫入讀出呢，說白了就是對文件的寫入和讀出，明白了這個層面就開始對一個文件操作下，比如新建個文本文檔，對裡面寫點內容，然後再讀出來，列印，就用最底層的位元組流就行了，凡是後面有stream的都是位元組流，Reader和writer是字元流，位元組流是一個位元組一個位元組讀取的，字元流是一個字元一個字元讀取，這個上的區別，你用中文測試下就明白了，因為中文的漢字是兩個位元組的，用位元組流讀出來是亂碼。
至於後面的web方面的開發並沒有想像中的那麼難，搞開發就是這樣的，得一步一步來，前面的沒學明白，搞明白先，到了後面就會輕松很多。因為後面的知識學起來貌似比前面的java se簡單。
對於這個項目的意義呢，除了幫助你們鞏固以前的知識外，就是想拓寬點你的思路，要不然到後面做大項目，遇上問題就不會自己解決了，你在培訓期間有老師給你們知道，出來到了公司上班，就只有網路和自己了，所以在做這個小項目的時候思路放開點，寫代碼認真點，以後你才能遇上任何問題都能解決。

我以前是學硬體的，剛開始學java se才學了一個星期，這一個星期我比你還痛苦，可是我每天都堅持敲代碼，在第七天的時候我按照自己的思路就能做出這樣的小游戲了。到後來我學java ee的時候就比別人快，現在在公司上班兩年，開發速度也比別人快，代碼的健壯性也比別人的好，為什麼呢？原因只有一個，在我學習的時候，別人只有白天敲敲代碼，我晚上還在敲，到了凌晨兩點才睡覺，我寫的多，遇上的問題比別人多，在開發上的經驗就比別人多，在後面解決問題的時候，別人要試好幾次才能弄出來，我直接寫出來，都不用想。

最後，既然選擇了開發，就一步一步學扎實，只要你靜下心來，抱著解決問題的態度去做項目，沒有你完不成的。
有什麼問題，我願意分享。祝春節愉快。

『陸』 俄羅斯方塊怎麼做(要思想)

不要留空的

『柒』 請寫一個俄羅斯方塊游戲程序的輪廓.(能夠說明你的思想就夠了)要求C++

樓主看著這里，很清晰，很詳細：
http://www.bysjlw.net/html/cankaolunwen/jisuanjiruanjian/20100926/7172.html

下面是摘要，看一下：
有前面的功能描述可知，我先虛擬出俄羅斯方塊游戲的類對象，並抽象出核心的數據屬性和操作方法等，然後再作細化，最後將整個虛擬類的外殼脫掉，再移植到視圖類中去，其實現如下：
CRectGameView : public CView
{
//內部存取數據結構
int m_stateMap[MAX_ROW][MAX_COL];
//初始化操作
GameInitnal(); //游戲的初始化

//用於判斷數據相關狀態的操作
IsLeftLimit(); //下墜物件是否可向左移動
IsRightLitmit(); //
IsBottom(); //是否已經到達了底部
IsGameEnd(); //是否游戲已經結束
//方塊物件下墜過程中的操作
RectChange(); //下墜物件變形
RectDown(); //下墜物件正常下落
RectArrow(); //下墜物件方向移動(左，右，下加速）
//狀態控制操作
GameStart(); //游戲開始
GamePause(); //游戲暫停
GameEnd(); //游戲結束
}
通過上面的代碼可以看出，在虛擬類中抽象出了核心的內部數據和一些基本的操作函數。對於操作函數，可以把它們分為內部實現的基本核心操作（如判斷操作）以及明顯提供給外部使用的整體模塊外部操作（如狀態控制操作）。而內部的基本操作又可以分為判斷操作和執行操作這樣兩種類型[3]。

『捌』 java版的俄羅斯方塊問題。定義方塊的形狀那個數組和生成新方塊的方法沒看懂，有高人解釋下不

/** 定義方塊的形狀那個數組和生成新方塊的方法沒看懂 */
下面這個是(三維數據)shapes中的一個二維元素
//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 } },

第一行{ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 } 畫出的圖形為:(0代表&,1代表O)
& & & &
O O O O
& & & &
& & & &
第二行{0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0}
& O & &
& O & &
& O & &
& O & &
從上面兩個你應該就可以看出這個數組存儲各種方塊的方式了。
blockType = (int) (Math.random() * 1000) % 7;
turnState = (int) (Math.random() * 1000) % 4;
這里取的7和4的原因是這個三維數組的兩個維度的大小是7和4,7種類型的圖形,和每個圖形的4種形態
反映到數組上就是
newShape[] = shapes[blockType][State] ;

『玖』 用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即可。