導航:首頁 > 觀俄羅斯 > 如何使用c製作軟俄羅斯方塊

如何使用c製作軟俄羅斯方塊

發布時間：2022-04-18 20:34:27

1. C語言設計俄羅斯方塊

1、將游戲區域劃分為18行*10列的棋盤，設立一個布爾型的二維數組變數，以表示棋盤上各個地方是否有方塊。
2、用4個頂點代表各種不同形狀的方塊，一旦方塊在游戲區域中，就把對應的布爾型二維數組變數置為真，表示該方格已經有方塊了。
3、如上做方便方塊移動是否會碰撞的判斷。
4、代碼已經修正了一個小BUG。
5、壓縮包中的文件是未經修改的源代碼，此處的代碼為最新。
6、方向鍵上為改變形狀，下為直接落到底部。p鍵為暫停（或者Pause鍵）。

2. 求C語言俄羅斯方塊代碼

俄羅斯方塊C源代碼

#include<stdio.h>

#include<windows.h>

#include<conio.h>

#include<time.h>

#defineZL4 //坐標增量,不使游戲窗口靠邊

#defineWID36 //游戲窗口的寬度

#defineHEI20 //游戲窗口的高度

inti,j,Ta,Tb,Tc; //Ta,Tb,Tc用於記住和轉換方塊變數的值

inta[60][60]={0}; //標記游戲屏幕各坐標點：0,1,2分別為空、方塊、邊框

intb[4]; //標記4個"口"方塊：1有，0無，類似開關

intx,y,level,score,speed; //方塊中心位置的x,y坐標，游戲等級、得分和游戲速度

intflag,next; //當前要操作的方塊類型序號，下一個方塊類型序號

voidgtxy(intm,intn); //以下聲明要用到的自編函數

voidgflag(); //獲得下一方塊序號

voidcsh(); //初始化界面

voidstart(); //開始部分

voidprfk(); //列印方塊

voidclfk(); //清除方塊

voidmkfk(); //製作方塊

voidkeyD(); //按鍵操作

intifmov(); //判斷方塊能否移動或變體

void clHA(); //清除滿行的方塊

voidclNEXT(); //清除邊框外的NEXT方塊

intmain()

{csh();

while(1)

{start();//開始部分

while(1)

{prfk();

Sleep(speed); //延時

clfk();

Tb=x;Tc=flag;//臨存當前x坐標和序號，以備撤銷操作

keyD();

y++;//方塊向下移動

if(ifmov()==0){y--;prfk();dlHA();break;}//不可動放下,刪行,跨出循環

}

for(i=y-2;i<y+2;i++){if(i==ZL){j=0;}} //方塊觸到框頂

if(j==0){system("cls");gtxy(10,10);printf("游戲結束！");getch();break;}

clNEXT(); //清除框外的NEXT方塊

}

return0;

}

voidgtxy(intm,intn)//控制游標移動

{COORDpos;//定義變數

pos.X=m;//橫坐標

pos.Y=n;//縱坐標

SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),pos);

}

voidcsh()//初始化界面

{gtxy(ZL+WID/2-5,ZL-2);printf("俄羅斯方塊");//列印游戲名稱

gtxy(ZL+WID+3,ZL+7);printf("*******NEXT：");//列印菜單信息

gtxy(ZL+WID+3,ZL+13);printf("**********");

gtxy(ZL+WID+3,ZL+15);printf("Esc：退出遊戲");

gtxy(ZL+WID+3,ZL+17);printf("↑鍵：變體");

gtxy(ZL+WID+3,ZL+19);printf("空格：暫停游戲");

gtxy(ZL,ZL);printf("╔");gtxy(ZL+WID-2,ZL);printf("╗");//列印框角

gtxy(ZL,ZL+HEI);printf("╚");gtxy(ZL+WID-2,ZL+HEI);printf("╝");

a[ZL][ZL+HEI]=2;a[ZL+WID-2][ZL+HEI]=2;//記住有圖案

for(i=2;i<WID-2;i+=2){gtxy(ZL+i,ZL);printf("═");}//列印上橫框

for(i=2;i<WID-2;i+=2){gtxy(ZL+i,ZL+HEI);printf("═");a[ZL+i][ZL+HEI]=2;}//下框

for(i=1;i<HEI;i++){gtxy(ZL,ZL+i);printf("║");a[ZL][ZL+i]=2;}//左豎框記住有圖案

for(i=1;i<HEI;i++){gtxy(ZL+WID-2,ZL+i);printf("║");a[ZL+WID-2][ZL+i]=2;}//右框

CONSOLE_CURSOR_INFOcursor_info={1,0};//以下是隱藏游標的設置

SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);

level=1;score=0;speed=400;

gflag();flag=next;//獲得一個當前方塊序號

}

voidgflag() //獲得下一個方塊的序號

{srand((unsigned)time(NULL));next=rand()%19+1; }

voidstart()//開始部分

{gflag();Ta=flag;flag=next;//保存當前方塊序號，將下一方塊序號臨時操作

x=ZL+WID+6;y=ZL+10;prfk();//給x,y賦值，在框外列印出下一方塊

flag=Ta;x=ZL+WID/2;y=ZL-1;//取回當前方塊序號，並給x,y賦值

}

voidprfk()//列印俄羅斯方塊

{for(i=0;i<4;i++){b[i]=1;}//數組b[4]每個元素的值都為1

mkfk();//製作俄羅斯方塊

for(i=x-2;i<=x+4;i+=2)//列印方塊

{for(j=y-2;j<=y+1;j++){if(a[i][j]==1&&j>ZL){gtxy(i,j);printf("□");}}}

gtxy(ZL+WID+3,ZL+1); printf("level:%d",level); //以下列印菜單信息

gtxy(ZL+WID+3,ZL+3); printf("score:%d",score);

gtxy(ZL+WID+3,ZL+5); printf("speed:%d",speed);

}

voidclfk()//清除俄羅斯方塊

{for(i=0;i<4;i++){b[i]=0;}//數組b[4]每個元素的值都為0

mkfk();//製作俄羅斯方塊

for(i=x-2;i<=x+4;i+=2)//清除方塊

{for(j=y-2;j<=y+1;j++){if(a[i][j]==0&&j>ZL){gtxy(i,j);printf("");}}}

}

voidmkfk()//製作俄羅斯方塊

{a[x][y]=b[0];//方塊中心位置狀態:1-有,0-無

switch(flag)//共6大類，19種小類型

{case1:{a[x][y-1]=b[1];a[x+2][y-1]=b[2];a[x+2][y]=b[3];break;}//田字方塊

case2:{a[x-2][y]=b[1];a[x+2][y]=b[2];a[x+4][y]=b[3];break;}//直線方塊:----

case3:{a[x][y-1]=b[1];a[x][y-2]=b[2];a[x][y+1]=b[3];break;}//直線方塊:|

case4:{a[x-2][y]=b[1];a[x+2][y]=b[2];a[x][y+1]=b[3];break;}//T字方塊

case5:{a[x][y-1]=b[1];a[x][y+1]=b[2];a[x-2][y]=b[3];break;}//T字順時針轉90度

case6:{a[x][y-1]=b[1];a[x-2][y]=b[2];a[x+2][y]=b[3];break;}//T字順轉180度

case7:{a[x][y-1]=b[1];a[x][y+1]=b[2];a[x+2][y]=b[3];break;}//T字順轉270度

case8:{a[x][y+1]=b[1];a[x-2][y]=b[2];a[x+2][y+1]=b[3];break;}//Z字方塊

case9:{a[x][y-1]=b[1];a[x-2][y]=b[2];a[x-2][y+1]=b[3];break;}//Z字順轉90度

case10:{a[x][y-1]=b[1];a[x-2][y-1]=b[2];a[x+2][y]=b[3];break;}//Z字順轉180度

case11:{a[x][y+1]=b[1];a[x+2][y-1]=b[2];a[x+2][y]=b[3];break;}//Z字順轉270度

case12:{a[x][y-1]=b[1];a[x][y+1]=b[2];a[x-2][y-1]=b[3];break;}//7字方塊

case13:{a[x-2][y]=b[1];a[x+2][y-1]=b[2];a[x+2][y]=b[3];break;}//7字順轉90度

case14:{a[x][y-1]=b[1];a[x][y+1]=b[2];a[x+2][y+1]=b[3];break;}//7字順轉180度

case15:{a[x-2][y]=b[1];a[x-2][y+1]=b[2];a[x+2][y]=b[3];break;}//7字順轉270度

case16:{a[x][y+1]=b[1];a[x][y-1]=b[2];a[x+2][y-1]=b[3];break;}//倒7字方塊

case17:{a[x-2][y]=b[1];a[x+2][y+1]=b[2];a[x+2][y]=b[3];break;}//倒7字順轉90度

case18:{a[x][y-1]=b[1];a[x][y+1]=b[2];a[x-2][y+1]=b[3];break;}//倒7字順轉180度

case19:{a[x-2][y]=b[1];a[x-2][y-1]=b[2];a[x+2][y]=b[3];break;}//倒7字順轉270度

}

voidkeyD()//按鍵操作

{if(kbhit())

{intkey;

key=getch();

if(key==224)

{key=getch();

if(key==75){x-=2;}//按下左方向鍵，中心橫坐標減2

if(key==77){x+=2;}//按下右方向鍵，中心橫坐標加2

if(key==72)//按下向上方向鍵,方塊變體

{if(flag>=2&&flag<=3){flag++;flag%=2;flag+=2;}

if(flag>=4&&flag<=7){flag++;flag%=4;flag+=4;}

if(flag>=8&&flag<=11){flag++;flag%=4;flag+=8;}

if(flag>=12&&flag<=15){flag++;flag%=4;flag+=12;}

if(flag>=16&&flag<=19){flag++;flag%=4;flag+=16;}}

}

if(key==32)//按空格鍵，暫停

{prfk();while(1){if(getch()==32){clfk();break;}}} //再按空格鍵，繼續游戲

if(ifmov()==0){x=Tb;flag=Tc;} //如果不可動，撤銷上面操作

else{prfk();Sleep(speed);clfk();Tb=x;Tc=flag;} //如果可動，執行操作

}

intifmov()//判斷能否移動

{if(a[x][y]!=0){return0;}//方塊中心處有圖案返回0，不可移動

else{if((flag==1&&(a[x][y-1]==0&&a[x+2][y-1]==0&&a[x+2][y]==0))||

(flag==2&&(a[x-2][y]==0&&a[x+2][y]==0&&a[x+4][y]==0))||

(flag==3&&(a[x][y-1]==0&&a[x][y-2]==0&&a[x][y+1]==0))||

(flag==4&&(a[x-2][y]==0&&a[x+2][y]==0&&a[x][y+1]==0))||

(flag==5&&(a[x][y-1]==0&&a[x][y+1]==0&&a[x-2][y]==0))||

(flag==6&&(a[x][y-1]==0&&a[x-2][y]==0&&a[x+2][y]==0))||

(flag==7&&(a[x][y-1]==0&&a[x][y+1]==0&&a[x+2][y]==0))||

(flag==8&&(a[x][y+1]==0&&a[x-2][y]==0&&a[x+2][y+1]==0))||

(flag==9&&(a[x][y-1]==0&&a[x-2][y]==0&&a[x-2][y+1]==0))||

(flag==10&&(a[x][y-1]==0&&a[x-2][y-1]==0&&a[x+2][y]==0))||

(flag==11&&(a[x][y+1]==0&&a[x+2][y-1]==0&&a[x+2][y]==0))||

(flag==12&&(a[x][y-1]==0&&a[x][y+1]==0&&a[x-2][y-1]==0))||

( flag==13 && ( a[x-2][y]==0 && a[x+2][y-1]==0 && a[x+2][y]==0 ) ) ||

( flag==14 && ( a[x][y-1]==0 && a[x][y+1]==0 && a[x+2][y+1]==0 ) ) ||

(flag==15 && ( a[x-2][y]==0 && a[x-2][y+1]==0 && a[x+2][y]==0 ) ) ||

(flag==16 && ( a[x][y+1]==0 && a[x][y-1]==0 && a[x+2][y-1]==0 ) ) ||

( flag==17 && ( a[x-2][y]==0 && a[x+2][y+1]==0 && a[x+2][y]==0 ) ) ||

(flag==18 && ( a[x][y-1]==0 &&a[x][y+1]==0 && a[x-2][y+1]==0 ) ) ||

(flag==19 && ( a[x-2][y]==0 && a[x-2][y-1]==0

&&a[x+2][y]==0))){return1;}

}

return0; //其它情況返回0

}

voidclNEXT() //清除框外的NEXT方塊

{flag=next;x=ZL+WID+6;y=ZL+10;clfk();}

void clHA() //清除滿行的方塊

{intk,Hang=0; //k是某行方塊個數,Hang是刪除的方塊行數

for(j=ZL+HEI-1;j>=ZL+1;j--)//當某行有WID/2-2個方塊時，則為滿行

{k=0;for(i=ZL+2;i<ZL+WID-2;i+=2)

{if(a[i][j]==1)//豎坐標從下往上，橫坐標由左至右依次判斷是否滿行

{k++; //下面將操作刪除行

if(k==WID/2-2) { for(k=ZL+2;k<ZL+WID-2;k+=2)

{a[k][j]=0;gtxy(k,j);printf("");Sleep(1);}

for(k=j-1;k>ZL;k--)

{for(i=ZL+2;i<ZL+WID-2;i+=2)//已刪行數上面有方塊，先清除再全部下移一行

{if(a[i][k]==1){a[i][k]=0;gtxy(i,k);printf("");a[i][k+1]=1;

gtxy(i,k+1);printf("□");}}

}

j++;//方塊下移後，重新判斷刪除行是否滿行

Hang++;//記錄刪除方塊的行數

}

score+=100*Hang; //每刪除一行，得100分

if(Hang>0&&(score%500==0||score/500>level-1)) //得分滿500速度加快升一級

{speed-=20;level++;if(speed<200)speed+=20; }

}

3. 一個簡單的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)遇到多行滿行時消除不了，
在判斷滿行時，循環找出滿行，找出一個滿行，就消除一行，然後繼續判斷是否滿行，直到遇到空行

4. 怎麼用c語言做俄羅斯方塊游戲要詳解

/*俄羅斯方塊*/

#include "Conio.h"
#include "graphics.h"
#include<stdio.h>
#include<stdlib.h>
#define closegr closegraph
#define WALL 9
#define BACK 6
#define PTC 4
#define DELC 15
#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b

void init();
void draw(int,int,int);
void drawpart(int);
void drawdp(int);
void newpart();
void start();
void sport();
void changedp();
int check(int);
int delmap();

int map[12][20],pat,gameover,i,j,k,w=1,speed=1,lingp=0;
long int score=0;
char scorec[20],speedc[10],lingpc[10];
struct node{
int x[4];
int y[4];
};
struct node part,dp;
void initgr(void) /* BGI初始化 */
{
int gd = DETECT, gm = 0; /* 和gd = VGA,gm = VGAHI是同樣效果 */
registerbgidriver(EGAVGA_driver);/* 注冊BGI驅動後可以不需要.BGI文件的支持運行 */
initgraph(&gd, &gm, "");
}
int main(void)
{
char ch;
init();
start();
while((ch=getch())!='Q'&&ch!='q')
{} /* 暫停一下，看看前面繪圖代碼的運行結果 */
closegr(); /* 恢復TEXT屏幕模式 */
return 0;
}

void init()
{
initgr(); /* BGI初始化 */
randomize();
setbkcolor(BACK);
setcolor(4);
setviewport(130,40,510,440,1);/*設置可活動區域*/
pat=0;
gameover=0;
sprintf(scorec,"SCORE:%ld",score);
outtextxy(250,300,scorec);
sprintf(speedc,"SPEED:%d",speed);
outtextxy(250,200,speedc);
sprintf(lingpc,"LINE:%d",lingp);
outtextxy(250,250,lingpc);
for(i=0;i<=380;i+=20)
{
draw(0,i,WALL);
draw(220,i,WALL);
draw(360,i,WALL);
}
for(i=20;i<=360;i+=20)
{
draw(i,0,WALL);
draw(i,380,WALL);
}
for(i=0;i<12;i++)
for(j=0;j<20;j++)
if(i==0||i==11||j==0||j==19)
map[i][j]=1;
else
map[i][j]=0;
newpart();
drawpart(PTC);
}

void draw(int x,int y,int p)/*畫小元件*/
{
setcolor(p);
rectangle(x+1,y+1,x+18,y+18);
rectangle(x+3,y+3,x+16,y+16);
}
void newpart()
{
int ran;
ran=rand()%7;
switch(ran)
{
case 0:
{
for(i=0;i<4;i++)
{
part.x[i]=i;
part.y[i]=0;
}
break;
}
case 1:
{
for(i=0;i<3;i++)
{
part.x[i]=i;
part.y[i]=1;
}
part.x[3]=2;
part.y[3]=0;
break;
}
case 2:
{
for(i=0;i<3;i++)
{
part.x[i]=i;
part.y[i]=0;
}
part.x[3]=2;
part.y[3]=1;
break;
}
case 3:
{
for(i=0;i<3;i++)
{
part.x[i]=i;
part.y[i]=0;
}
part.x[3]=1;
part.y[3]=1;
break;
}
case 4:
{
for(i=0;i<2;i++)
{
part.x[i]=i;
part.y[i]=0;
}
for(i=2;i<4;i++)
{
part.x[i]=i-1;
part.y[i]=1;
}
break;
}
case 5:
{
for(i=0;i<2;i++)
{
part.x[i]=i;
part.y[i]=1;
}
for(i=2;i<4;i++)
{
part.x[i]=i-1;
part.y[i]=0;
}
break;
}
case 6:
{
for(i=0;i<2;i++)
{
part.x[i]=i;
part.y[i]=0;
part.x[i+2]=i;
part.y[i+2]=1;
}
break;
}
}
}
void drawpart(int color)
{
for(i=0;i<4;i++)
draw(260+(part.x[i])*20,40+(part.y[i])*20,color);
}
void drawdp(int color)
{
for(i=0;i<4;i++)
draw((dp.x[i])*20,(dp.y[i])*20,color);
}
void start()
{

while(gameover==0)
{
sport();
if(delmap()==1)
{
setcolor(BACK);
outtextxy(250,300,scorec);
outtextxy(250,200,speedc);
sprintf(scorec,"SCORE:%ld",score);
sprintf(speedc,"SPEED:%d",speed);
setcolor(PTC);
outtextxy(250,300,scorec);
outtextxy(250,200,speedc);
}
setcolor(BACK);
outtextxy(250,250,lingpc);
sprintf(lingpc,"LINE:%d",lingp);
setcolor(PTC);
outtextxy(250,250,lingpc);

}
setcolor(15);
settextstyle(0,0,4);
outtextxy(50,180,"GAME OVER");
settextstyle(0,0,1);
outtextxy(70,220,"PRESS Q TO QUIT GAME.");
}
void sport()
{
int delayn=0,key,delayt;
drawpart(BACK);
pat=0;
for(i=0;i<4;i++)
{
dp.x[i]=part.x[i]+4;
dp.y[i]=part.y[i]+2;
}
if(check(1)==1){gameover=1;pat=1;}
newpart();
drawpart(PTC);
drawdp(PTC);
while(pat==0)
{
while(!kbhit())
{
if(speed<=9)
delayt=3300-speed*300;
else
delayt=600;
delay(delayt*w);
delayn++;
if(delayn%100)
continue;
delayn=0;
if(check(1)==1)
{
for(i=0;i<4;i++)
map[dp.x[i]][dp.y[i]]=1;
pat=1;
break;
}
drawdp(BACK);
changedp(1);
drawdp(PTC);
}
w=1;
if(pat==1)break;
key=bioskey(0);
if(key==ESC)
{
exit(0);
}
else if(key==DOWN)
{
w=0;
}
else if(key==LEFT)
{
if(check(2)==0){drawdp(BACK);changedp(2);drawdp(PTC); }
}
else if(key==RIGHT)
{
if(check(0)==0){drawdp(BACK);changedp(0);drawdp(PTC); }
}
else if(key==UP)
{
if(check(3)==0){drawdp(BACK);changedp(3);drawdp(PTC);}
}
}
}
void changedp(int p)
{
int ex,rx,ry;
switch(p)
{
case 1:
{
for(i=0;i<4;i++)
dp.y[i]++;
break;
}
case 2:
{
for(i=0;i<4;i++)
dp.x[i]--;
break;
}
case 0:
{
for(i=0;i<4;i++)
dp.x[i]++;
break;
}
case 3:
{
for(i=0;i<4;i++)
if(i!=1)
{
ex=dp.x[i];
dp.x[i]=dp.x[1]+dp.y[1]-dp.y[i];
dp.y[i]=dp.y[1]-dp.x[1]+ex;
}
break;
}
}

}
int check(int p)
{
struct node chp;
switch(p)
{
case 1:
{
for(i=0;i<4;i++)
if(map[dp.x[i]][dp.y[i]+1]==1)
return 1;
break;
}
case 2:
{
for(i=0;i<4;i++)
if(map[dp.x[i]-1][dp.y[i]]==1)
return 1;
break;
}
case 0:
{
for(i=0;i<4;i++)
if(map[dp.x[i]+1][dp.y[i]]==1)
return 1;
break;
}
case 3:
{
for(i=0;i<4;i++)
{
chp.x[i]=dp.x[i];
chp.y[i]=dp.y[i];
}
changedp(3);
for(j=0;j<4;j++)
if(map[dp.x[j]][dp.y[j]]==1)
{
for(i=0;i<4;i++)
{
dp.x[i]=chp.x[i];
dp.y[i]=chp.y[i];
}
return 1;
}
for(i=0;i<4;i++)
{
dp.x[i]=chp.x[i];
dp.y[i]=chp.y[i];
}
break;
}
}
return 0;
}
int delmap()
{
int sum,m=0;
for(i=18;i>1;i--)
{
sum=0;
for(j=1;j<=10;j++)
sum+=map[j][i];
if(sum==10)
{
m++;
for(k=1;k<=10;k++)
{
delay(6000);
draw(k*20,i*20,DELC);
}
for(k=i;k>1;k--)
for(j=1;j<=10;j++)
{
map[j][k]=map[j][k-1];
if(map[j][k]==1)draw(j*20,k*20,PTC);
else draw(j*20,k*20,BACK);
}
i++;
}
}
switch(m)
{
case 0:break;
case 1:
{score+=100;break;}
case 2:
{score+=300;break;}
case 3:
{score+=1000;break;}
case 4:
{score+=1600;break;}
}
speed=(int)score/10000+1;
lingp+=m;
if(m==0)return 0;
else return 1;
}

5. 如何用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

6. C語言中俄羅斯方塊怎麼做

當時做得時候工具用turboC
2.0開發的，課程設計.
具體的代碼網上可以搜到很多，我就不細說了.
當時編碼的時候，通常把俄羅斯方塊的編碼工作分成幾個小塊完成，我描述一下:
1.
當前下落塊的控制邏輯.
2.
用戶輸入的控制邏輯，這個是用中斷控制，比如bioskey()函數去獲取當前的輸入值，具體的我記不清了.
3.
判斷一行是否能夠消去邏輯(公共環境是用20*12的數組來存放.)
4.
難度以及其他配置模塊管理，模塊劃分清楚之後，編碼較為容易.
希望可以有幫助:
)

7. 用C語言俄羅斯方塊製作

下面的源碼可以直接在tc下運行

現在打算在vc下用mfc試著編一下

#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <graphics.h>

#define VK_LEFT 0x4b00
#define VK_RIGHT 0x4d00
#define VK_DOWN 0x5000
#define VK_UP 0x4800
#define VK_ESC 0x011b
#define TIMER 0x1c

#define MAX_BOX 19
#define BSIZE 20
#define Sys_x 160
#define Sys_y 25
#define Horizontal_boxs 10
#define Vertical_boxs 15
#define Begin_boxs_x Horizontal_boxs/2
#define FgColor 3
#define BgColor 0
#define LeftWin_x Sys_x+Horizontal_boxs*BSIZE+46
#define false 0
#define true 1
#define MoveLeft 1
#define MoveRight 2
#define MoveDown 3
#define MoveRoll 4

int current_box_numb;
int Curbox_x=Sys_x+Begin_boxs_x*BSIZE,Curbox_y=Sys_y;
int flag_newbox=false;
int speed=1;
int score=0;
int speed_step=30;
void interrupt(*oldtimer)(void);

struct BOARD
{
int var;
int color;

}Table_board[Vertical_boxs][Horizontal_boxs];

struct SHAPE
{
char box[2];
int color;
int next;
};

struct SHAPE shapes[MAX_BOX]=
{
{0x88,0xc0,CYAN,1},
{0xe8,0x0,CYAN,2},
{0xc4,0x40,CYAN,3},
{0x2e,0x0,CYAN,0},

{0x44,0xc0,MAGENTA,5},
{0x8e,0x0,MAGENTA,6},
{0xc8,0x80,MAGENTA,7},
{0xe2,0x0,MAGENTA,4},

{0x8c,0x40,YELLOW,9},
{0x6c,0x0,YELLOW,8},

{0x4c,0x80,BROWN,11},
{0xc6,0x0,BROWN,10},

{0x4e,0x0,WHITE,13},
{0x8c,0x80,WHITE,14},
{0xe4,0x0,WHITE,15},
{0x4c,0x40,WHITE,12},

{0x88,0x88,RED,17},
{0xf0,0x0,RED,16},

{0xcc,0x0,BLUE,18},

};

unsigned int TimerCounter=0;

void initialize(int,int,int,int);
void interrupt newtimer(void);
void SetTimer(void interrupt(*IntProc)(void));
void KillTimer(void);
void ShowScore(int);
void ShowSpeed(int);
void show_help(int,int);
void setFullRow(int);
int DelFullRow(int);
void show_box(int,int,int,int);
void EraseBox(int,int,int);
void ErasePreBox(int,int,int);
int MkNextBox(int);
int MoveAble(int,int,int,int);

void main()
{
int GameOver=0;
int key,nextbox;
int Currentaction=0;
int gd=VGA,gm=VGAHI,errorcode;
initgraph(&gd,&gm,"");
errorcode=graphresult();
if(errorcode!=grOk)
{
printf("\nNotice:Graphics error: %s\n",grapherrormsg(errorcode));
printf("Press any key to quit!");
getch();
exit(1);
}
setbkcolor(BgColor);
setcolor(FgColor);
randomize();
SetTimer(newtimer);
initialize(Sys_x,Sys_y,Horizontal_boxs,Vertical_boxs);
nextbox=MkNextBox(-1);
show_box(Curbox_x,Curbox_y,current_box_numb,shapes[current_box_numb].color);
show_box(LeftWin_x,Curbox_y+320,nextbox,shapes[nextbox].color);
show_help(Sys_x,Curbox_y+320);

getch();

while (1)
{
Currentaction=0;
flag_newbox=false;
if(bioskey(1))
{
key=bioskey(0);
}
else
{
key=0;
}
switch(key)
{
case VK_LEFT:
if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveLeft))
{
EraseBox(Curbox_x,Curbox_y,current_box_numb);
Curbox_x-=BSIZE;
Currentaction=MoveLeft;
}
break;
case VK_RIGHT:
if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveRight))
{
EraseBox(Curbox_x,Curbox_y,current_box_numb);
Curbox_x+=BSIZE;
Currentaction=MoveRight;
}
break;
case VK_DOWN:
if(MoveAble(Curbox_x,Curbox_y,current_box_numb,MoveDown))
{
EraseBox(Curbox_x,Curbox_y,current_box_numb);
Curbox_y+=BSIZE;
Currentaction=MoveDown;
}
else
flag_newbox=true;
break;
case VK_UP:
if(MoveAble(Curbox_x,Curbox_y,shapes[current_box_numb].next,MoveRoll))
{
EraseBox(Curbox_x,Curbox_y,current_box_numb);
current_box_numb=shapes[current_box_numb].next;
Currentaction=MoveLeft;
}
break;
case VK_ESC:
GameOver=1;
break;
default:
break;
}

8. 怎樣用c語言編寫俄羅斯方塊程序