㈠ 能不能介紹點c語言編程的小游戲，例如貪吃蛇，。。好玩點的。要有代碼，謝謝了
可以學寫「俄羅斯方塊」代碼：
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <windows.h>
#define ZL 4 //坐標增量, 不使游戲窗口靠邊
#define W 36 //游戲窗口的寬度
#define H 20 //游戲窗口的高度
int i,j,Ta,Tb,Tc; // Ta,Tb,Tc用於記住和轉換方塊變數的值
int a[60][60]={0}; //標記游戲屏幕各坐標點：0,1,2分別為空、方塊、邊框
int b[4]; //標記4個"口"方塊：1有，0無，類似開關
int x,y, level,score,speed; //方塊中心位置的x,y坐標，游戲等級、得分和游戲速度
int flag,next; //當前要操作的方塊類型序號，下一個方塊類型序號
void gtxy(int m, int n); //以下聲明要用到的自編函數
void setColor(unsigned short p, unsigned short q); //設定顯示顏色
void gflag( ); //獲得下一方塊類型的序號
void csh( ); //初始化界面
void start( ); //開始部分
void prfk ( ); //列印方塊
void clfk( ); //清除方塊
void mkfk( ); //製作方塊
void keyD( ); //按鍵操作
int ifmov( ); //判斷能否移動
void clHA( ); //清除滿行的方塊
void clNEXT( ); //清除邊框外的NEXT方塊
int main( )
{ csh( );
while(1)
{ start( );
while(1)
{ setColor(5, 0);
prfk( ); Sleep(speed); clfk( );
Tb=x;Tc=flag; //臨存當前x坐標和序號，以備撤銷操作
keyD( );
y++; //方塊向下移動
if (ifmov( )==0) { y--; setColor(2, 0);prfk( ); clHA( ); break;} //不可動時的操作
}
for(i=y-2;i<y+2;i++){ if (i==ZL) { j=0; } } //方塊觸到框頂
if (j==0) { system("cls");gtxy(10,10); setColor(6, 0);
printf("游戲結束！"); getch(); break; }
clNEXT( );
}
return 0;
}
void gtxy(int m, int n) //控制游標移動
{COORD pos; //定義變數
pos.X = m; //橫坐標
pos.Y = n; //縱坐標
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos); //獲得顯示器句柄
}
void setColor(unsigned short ForeColor = 7, unsigned short BackGroundColor = 0)
{ HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
SetConsoleTextAttribute(handle, ForeColor + BackGroundColor * 0x10);
}
void csh( ) //初始化界面
{gtxy(ZL+W/2-5,ZL-2); setColor(10, 0); printf("俄羅斯方塊"); //列印游戲名稱
gtxy(ZL+W+3,ZL+7); setColor(5, 0);printf("******* NEXT："); //列印菜單信息
gtxy(ZL+W+3,ZL+13); setColor(5, 0);printf("************");
gtxy(ZL+W+3,ZL+15); setColor(9, 0);printf("Esc ：退出遊戲");
gtxy(ZL+W+3,ZL+17); setColor(9, 0);printf("↑鍵：變體");
gtxy(ZL+W+3,ZL+19); setColor(9, 0);printf("空格：暫停游戲");
gtxy(ZL,ZL); setColor(2, 0); printf("╔"); gtxy(ZL+W-2,ZL); printf("╗"); //列印框角
gtxy(ZL,ZL+H); printf("╚"); gtxy(ZL+W-2,ZL+H); printf("╝");
a[ZL][ZL+H]=2; a[ZL+W-2][ZL+H]=2; //記住有圖案
for(i=2;i<W-2;i+=2) {gtxy(ZL+i,ZL); printf("═"); } //列印上橫框
for(i=2;i<W-2;i+=2) {gtxy(ZL+i,ZL+H); printf("═"); a[ZL+i][ZL+H]=2; } //列印下橫框有圖案
for(i=1;i<H;i++) { gtxy(ZL,ZL+i); printf("║"); a[ZL][ZL+i]=2; } //列印左豎框記住有圖案
for(i=1;i<H;i++) {gtxy(ZL+W-2,ZL+i); printf("║"); a[ZL+W-2][ZL+i]=2; } //列印右豎框有圖案
CONSOLE_CURSOR_INFO cursor_info={1,0}; //以下是隱藏游標的設置
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE),&cursor_info);
level=1; score=0; speed=400;
gflag( ); flag=next; //獲得一個當前方塊序號
}
void gflag( ) //獲得下一個方塊類型的序號
{ srand((unsigned)time(NULL)); next = rand()%19+1; }
void start( ) //開始部分
{ gflag( ); Ta=flag; flag=next; //保存當前方塊序號，將下一方塊序號臨時操作
x=ZL+W+6; y=ZL+10; setColor(5, 0); prfk( ); //給x,y賦值，在框外列印出下一方塊
flag=Ta; x=ZL+W/2; y=ZL-1; //取回當前方塊序號，並給x,y賦值
}
void prfk ( ) //列印俄羅斯方塊
{ 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+W+3,ZL+1); setColor(9, 0); printf("level : %d",level); //以下列印菜單信息
gtxy(ZL+W+3,ZL+3); setColor(9, 0); printf("score : %d",score);
gtxy(ZL+W+3,ZL+5); setColor(9, 0); printf("speed : %d",speed);
}
void clfk( ) //清除俄羅斯方塊
{ 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(" "); } } }
}
void mkfk( ) //製作俄羅斯方塊
{ a[x][ y]=b[0]; //方塊中心位置狀態: 1-有,0-無
switch(flag) //共6大類，19種小類型
{ case 1: { a[x][y-1]=b[1]; a[x+2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //田字方塊
case 2: { a[x-2][y]=b[1]; a[x+2][y]=b[2]; a[x+4][y]=b[3]; break; } //直線方塊:----
case 3: { a[x][y-1]=b[1]; a[x][y-2]=b[2]; a[x][y+1]=b[3]; break; } //直線方塊: |
case 4: { a[x-2][y]=b[1]; a[x+2][y]=b[2]; a[x][y+1]=b[3]; break; } //T字方塊
case 5: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x-2][y]=b[3]; break; } //T字順時針轉90度
case 6: { a[x][y-1]=b[1]; a[x-2][y]=b[2]; a[x+2][y]=b[3]; break; } //T字順轉180度
case 7: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x+2][y]=b[3]; break; } //T字順轉270度
case 8: { a[x][y+1]=b[1]; a[x-2][y]=b[2]; a[x+2][y+1]=b[3]; break; } //Z字方塊
case 9: { a[x][y-1]=b[1]; a[x-2][y]=b[2]; a[x-2][y+1]=b[3]; break; } //Z字順轉90度
case 10: { a[x][y-1]=b[1]; a[x-2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //Z字順轉180度
case 11: { a[x][y+1]=b[1]; a[x+2][y-1]=b[2]; a[x+2][ y]=b[3]; break; } //Z字順轉270度
case 12: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x-2][y-1]=b[3]; break; } //7字方塊
case 13: {a[x-2][y]=b[1]; a[x+2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //7字順轉90度
case 14: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x+2][y+1]=b[3]; break; } //7字順轉180度
case 15: { a[x-2][y]=b[1]; a[x-2][y+1]=b[2]; a[x+2][y]=b[3]; break; } //7字順轉270度
case 16: { a[x][y+1]=b[1]; a[x][y-1]=b[2]; a[x+2][y-1]=b[3]; break; } //倒7字方塊
case 17: { a[x-2][y]=b[1]; a[x+2][y+1]=b[2]; a[x+2][y]=b[3]; break; } //倒7字順轉90度
case 18: { a[x][y-1]=b[1]; a[x][y+1]=b[2]; a[x-2][y+1]=b[3]; break; } //倒7字順轉180度
case 19: { a[x-2][y]=b[1]; a[x-2][y-1]=b[2]; a[x+2][y]=b[3]; break; } //倒7字順轉270度
}
}
void keyD( ) //按鍵操作
{ if (kbhit( ))
{ int key;
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) //按空格鍵，暫停
{ setColor(5, 0);prfk( ); while(1) { if (getch( )==32) { clfk( );break;} } } //再按空格鍵，繼續游戲
if (ifmov( )==0) { x=Tb; flag=Tc; } //如果不可動，撤銷上面操作
else { setColor(5, 0); prfk( ); Sleep(speed); clfk( ); Tb=x;Tc=flag;} //如果可動，執行操作
}
}
int ifmov( ) //判斷能否移動
{ if (a[x][y]!=0) { return 0; } //方塊中心處有圖案返回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 ) ) ) { return 1; }
}
return 0; //其它情況返回0
}
void clNEXT( ) //清除邊框外的NEXT方塊
{ flag = next; x=ZL+W+6; y=ZL+10; clfk( ); }
void clHA( ) //清除滿行的方塊
{ int k, Hang=0; //k是某行方塊個數, Hang是刪除的方塊行數
for(j=ZL+H-1;j>=ZL+1;j--) //當某行有W/2-2個方塊時，則為滿行
{ k=0; for(i=ZL+2;i<ZL+W-2;i+=2)
{ if (a[i][j]==1) //豎坐標從下往上，橫坐標由左至右依次判斷是否滿行
{ k++; //下面將操作刪除行
if (k==W/2-2) { for(k=ZL+2;k<ZL+W-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+W-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);
setColor(2, 0); 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;}
}
㈡ 只會C語言編程還要學哪些才能做俄羅斯方塊這樣的小游戲
熟練掌握學懂C語言，再加上 microsoft visual c++ 6 作為編譯器 就可以製作出俄羅斯方塊這樣的小游戲。也可以製作
2D游戲、 3D游戲 、動畫、音樂播放器、 網站網頁系統等。
C語言是一種計算機程序設計語言，屬高級語言范疇。它既具有高級語言的特點，又具有匯編語言的特點。它可以作為工作系統設計語言，編寫系統應用程序，也可以作為應用程序設計語言，編寫不依賴計算機硬體的應用程序，代碼清晰精簡，十分靈活。
相關的特性：
1、對齊處理(Alignment）的標准化（包括_Alignas標志符，alignof運算符,aligned_alloc函數以及<stdalign.h>頭文件。
2、_Noreturn 函數標記，類似於 gcc 的 __attribute__((noreturn))。
3、_Generic 關鍵字。
4、多線程(Multithreading）支持，包括：_Thread_local存儲類型標識符，<threads.h>；頭文件，裡麵包含了線程的創建和管理函數。
5、增強的Unicode的支持，基於C Unicode技術報告ISO/IEC TR 19769:2004，增強了對Unicode的支持。包括為UTF-16/UTF-32編碼增加了char16_t和char32_t數據類型，提供了包含unicode字元串轉換函數的頭文件<uchar.h>.
6、刪除了 gets() 函數，使用一個新的更安全的函數gets_s（）替代。
7、增加了邊界檢查函數介面，定義了新的安全的函數，例如 fopen_s（），strcat_s() 等等。
8、增加了更多浮點處理宏。
9、匿名結構體/聯合體支持，這個在gcc早已存在，C11將其引入標准。
10、靜態斷言（Static assertions），_Static_assert（），在解釋 #if 和 #error 之後被處理。
11、新的 fopen() 模式，（「…x」），類似 POSIX 中的 O_CREAT|O_EXCL，在文件鎖中比較常用。
12、新增 quick_exit() 函數作為第三種終止程序的方式。當 exit（）失敗時可以做最少的清理工作。
13、_Atomic類型修飾符和<stdatomic.h>頭文件。
㈢ 剛剛學了C語言，想寫點程序，有什麼好玩的呢
自己博客上的文章
很多人對學習C語言感到無從下手，經常問我同一個問題：究竟怎樣學習C語言？我是一個教師，已經開發了很多年的程序，和很多剛剛起步的人一樣，學習的第一個計算機語言就是C語言。經過這些年的開發，我深深的體會到C語言對於一個程序設計人員多麼的重要，如果不懂C語言，你想寫底層程序這幾乎聽起來很可笑，不懂C語言，你想寫出優秀高效的程序，這簡直就是天方夜譚。為什麼C語言如此重要呢？
第一:C語言語法結構很簡潔精妙，寫出的程序也很高效，很便於描述演算法，大多數的程序員願意使用C語言去描述演算法本身，所以，如果你想在程序設計方面有所建樹，就必須去學它。
第二：C語言能夠讓你深入系統底層，你知道的操作系統，哪一個不是C語言寫的？所有的windows,Unix,Linux,Mac,os/2，沒有一個里外的，如果你不懂C語言，怎麼可能深入到這些操作系統當中去呢？更不要說你去寫它們的內核程序了。
第三：很多新型的語言都是衍生自C語言，C++,Java,C#,J#,perl...哪個不是呢？掌握了C語言，可以說你就掌握了很多門語言，經過簡單的學習，你就可以用這些新型的語言去開發了，這個再一次驗證了C語言是程序設計的重要基礎。還有啊，多說一點：即使現在招聘程序員，考試都是考C語言，你想加入it行業，那麼就一定要掌握好C語言。
那麼究竟怎樣學習C語言呢？
1:工欲善其事，必先利其器
這里介紹幾個學習C語言必備的東東：
一個開發環境，例如turbo?C?2.0,這個曾經占據了DOS時代開發程序的大半個江山。但是現在windows時代，用turbo?C有感覺不方面，編輯程序起來很吃力，並且拖放，更沒有函數變數自動感應功能，查詢參考資料也不方便。建議使用Visual C++,這個東西雖然比較大塊頭，但是一旦安裝好了，用起來很方便。
一本學習教程,現在C語言教材多如牛毛，但推薦大家使用《C語言程序設計》譚浩強主編 第二版 清華大學出版社，此書編寫的很適合初學者，並且內容也很精到。
除此以外，現在有很多輔助學習的軟體，畢竟現在是Window時代了，學習軟體多如牛毛，不象我們當初學習，只有讀書做題這么老套。我向大家推薦一個「集成學習環境(C語言)」，里邊的知識點總結和常式講解都非常好，還有題庫測試環境，據說有好幾千題，甚至還有一個windows下的trubo?C，初學者甚至不用裝其它的編譯器，就可以練習編程了,非常適合初學者。還有一個「C語言學習系統」軟體，不過感覺只是一個題庫系統，如果你覺得題做的不夠，不妨也可以試試。
2:葵花寶典
學習計算機語言最好的方法是什麼？答曰：讀程序。
沒錯，讀程序是學習C語言入門最快，也是最好的方法。如同我，現在學習新的J#,C#等其他語言，不再是抱著書本逐行啃，而是學習它們的常式。當然，對於沒有學過任何計算機語言的初學者，最好還是先閱讀教程，學習完每一章，都要認真體會這一章的所有概念，然後不放過這一章中提到的所有常式，然後仔細研讀程序，直到每一行都理解了，然後找幾個編程題目，最好是和常式類似的或一樣的，自己試圖寫出這段已經讀懂的程序，不要以為常式你已經讀懂了，你就可以寫出和它一樣的程序，絕對不一定，不相信你就試一試吧，如果寫不出來，也不要著急，回過頭來再繼續研究常式，想想自己為什麼寫不出來，然後再去寫這段程序，反反復復，直到你手到擒來為止，祝賀你，你快入門了。
3：登峰造極
寫程序的最高境界其實就是掌握各種解決問題的手段(數據結構)和解決問題的方法(演算法)。?
是不是寫出底層程序就是程序設計高手呢？非也，寫底層程序，無非是掌握了硬體的結構，況且硬體和硬體還不一樣，要給一個晶元寫驅動程序，無非就是掌握這塊晶元的各種寄存器及其組合，然後寫值讀值，僅此而已。這不過是熟悉一些io函數罷了。
那麼怎樣才算精通程序設計呢？怎樣才能精通程序設計呢？舉個例子：你面前有10個人，找出一個叫「張三」的人，你該怎麼辦？第一種方法：直接對這10個人問：「誰叫張三」。第2種方法：你挨個去問「你是不是張三？」，直到問到的這個人就是張三。第三種方法：你去挨個問一個人「你認不認識張三，指給我看」。不要小看這個問題，你說當然會選第一種方法，沒錯恭喜你答對了，因為這個方法最快，效率最高，但是在程序設計中找到解決問題的最優方法和你用的手段卻是考驗一個程序員程序設計水平的重要標志，而且是不容易達到的。剛才這個問題類似於數據結構和演算法中的：Map數據結構，窮舉查找和折半查找。所以掌握好數據結構和一些常用演算法，是登峰造極的必然之路。
㈣ 有C語言基礎想開發游戲，還需要學哪些
你可以先去【繪學霸】網站找「游戲特效/unity3D」板塊的【免費】視頻教程-【點擊進入】完整入門到精通視頻教程列表： www.huixueba.net/web/AppWebClient/AllCourseAndResourcePage?type=1&tagid=305,306&zdhhr-11y17r-694997618062854084
想要系統的學習可以考慮報一個網路直播課，推薦CGWANG的網路課。老師講得細，上完還可以回看，還有同類型錄播課可以免費學（贈送終身VIP）。
自製能力相對較弱的話，建議還是去好點的培訓機構，實力和規模在國內排名前幾的大機構，推薦行業龍頭：王氏教育。
王氏教育全國直營校區面授課程試聽【復制後面鏈接在瀏覽器也可打開】：
www.cgwang.com/course/gecoursemobilecheck/?zdhhr-11y17r-694997618062854084
在「游戲特效/unity3D」領域的培訓機構里，【王氏教育】是國內的老大，且沒有加盟分校，都是總部直營的連鎖校區。跟很多其它同類型大機構不一樣的是：王氏教育每個校區都是實體面授，老師是手把手教，而且有專門的班主任從早盯到晚，爆肝式的學習模式，提升會很快，特別適合基礎差的學生。
大家可以先把【繪學霸】APP下載到自己手機，方便碎片時間學習——繪學霸APP下載： www.huixueba.com.cn/Scripts/download.html
㈤ 用c語言編寫石頭剪刀布的游戲要求如下
用誒語言來編寫一個石頭剪刀布的游戲，那麼就是。然後做一個設定，因為你得設定兩個人去玩兒，因為剪刀石頭布。你需要兩個又紅又殘忍。
㈥ 能不能介紹點C語言編程的小游戲，好玩點的。要有代碼，謝謝了。
#include<stdio.h>
#include<conio.h>
#include<time.h>
#include"consoleout.h"
#pragma comment(lib,"consoleout.lib")
void main();
//板的當前位置
int g_nBarX = 4;
int g_nBarY = 24;
//球的當前位置
int g_nBallX = g_nBarX + 4;
int g_nBallY = g_nBarY - 2;
//速度(g_nBallVx,g_nBallVy)
int g_nBallVx = 1;
int g_nBallVy = -1;
int a,b,n;
static int nOldX = g_nBallX = 4;
static int nOldY = g_nBallY = 20;
//功能:移動溜板
void BarMove(char cC)
{
static int nOldX = g_nBarX;
static int nOldY = g_nBarY;
if(cC == 'a'||cC == 'A')
{
g_nBarX = nOldX - 8;
}
else if(cC == 'd'||cC == 'D')
{
g_nBarX= nOldX + 8;
}
//防止出右邊界
if(g_nBarX > 58)
{
g_nBarX = 58;
}
//防止出左邊界
if(g_nBarX < 2)
{
g_nBarX = 2;
}
CreateSmWindow("",nOldX,nOldY,10,3,0,0);
CreateSmWindow("",g_nBarX,g_nBarY,10,3,12,0);
nOldX = g_nBarX;
}
//功能:繪制小球的彈動
void BallMove()
{
if(g_nBallX == 2||g_nBallX == 76)
{
g_nBallVx = -g_nBallVx;
}
if(g_nBallY == 1||g_nBallY== 26)
{
g_nBallVy = -g_nBallVy;
}
g_nBallX = nOldX + g_nBallVx;
g_nBallY = nOldY + g_nBallVy;
MoveCursorTo(nOldX,nOldY);
printf(" ");
MoveCursorTo(g_nBallX,g_nBallY);
printf("●");
nOldX = g_nBallX;
nOldY = g_nBallY;
MoveCursorTo(0,29);
printf("球:位置:(%d,%d)",g_nBallX,g_nBallY);
sleep(b);
switch(a)
{
case 1: b = 70;break;
case 2: b = 40;break;
case 3: b = 5;break;
}
}
//功能:判斷球與板的位置，如果碰到就反彈球
//返回值:改變運行方向
void Pop()
{
//判斷小球落在板上
if(g_nBarX < g_nBallX && g_nBallX < g_nBarX + 24 && g_nBallY > g_nBarY - 2)
{
g_nBallVy = -g_nBallVy;
}
}
void MainLoop()
{
while(1)
{
if(_kbhit() == 1)
{
char c = _getch();
if(c == 27)
{
printf("Game Over!\n");
break;
}
BarMove(c);
}
BallMove();
Pop();
sleep(5);
if(g_nBallY > 24)
{
CreateSmWindow("彈球游戲\n",0,0,40,28,11,0);
MoveCursorTo(35,12);
printf("游戲結束!\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
sleep(1000);
break;
}
}
CreateSmWindow("彈球游戲\n",0,0,40,28,10,0);
MoveCursorTo(35,14);
printf("1.重新開始");
MoveCursorTo(35,16);
SetTextColor(11,0);
printf("2.退出");
MoveCursorTo(25,12);
SetTextColor(10,0);
printf("請選擇(選擇完畢按回車鍵確認):");
MoveCursorTo(54,12);
scanf("%d",&n);
if(n == 1)
{
g_nBarX = 4;
g_nBarY = 24;
g_nBallX = g_nBarX + 4;
g_nBallY = g_nBarY - 2;
g_nBallVx = 1;
g_nBallVy = -1;
nOldX = g_nBallX = 4;
nOldY = g_nBallY = 20;
CreateSmWindow("彈球游戲\n",0,0,40,28,10,0);
MoveCursorTo(22,8);
SetTextColor(11,0);
printf("(提示:請把游戲窗口調整到最大化)");
MoveCursorTo(25,10);
printf("(控制鍵介紹:左 A ; 右 D)");
MoveCursorTo(32,14);
SetTextColor(10,0);
printf("1.簡單");
MoveCursorTo(32,16);
printf("2.中等");
MoveCursorTo(32,18);
printf("3.困難");
MoveCursorTo(18,12);
printf("請選擇游戲難度(選擇完畢按回車鍵開始游戲):\n");
MoveCursorTo(59,12);
scanf("%d",&a);
CreateSmWindow("彈球游戲\n",0,0,40,28,13,0);
MoveCursorTo(32,12);
SetTextColor(9,0);
printf("★游戲開始★");
sleep(1200);
CreateSmWindow("彈球游戲",0,0,40,28,13,0);
MainLoop();
}
else if(n == 2)
{
CreateSmWindow("彈球游戲\n",0,0,40,28,10,0);
MoveCursorTo(32,12);
SetTextColor(11,0);
printf("請按任意鍵退出\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
}
}
void main()
{
CreateSmWindow("彈球游戲\n",0,0,40,28,10,0);
MoveCursorTo(22,8);
SetTextColor(11,0);
printf("(提示:請把游戲窗口調整到最大化)");
MoveCursorTo(25,10);
printf("(控制鍵介紹:左 A ; 右 D)");
MoveCursorTo(32,14);
SetTextColor(10,0);
printf("1.簡單");
MoveCursorTo(32,16);
printf("2.中等");
MoveCursorTo(32,18);
printf("3.困難");
MoveCursorTo(18,12);
printf("請選擇游戲難度(選擇完畢按回車鍵開始游戲):\n");
MoveCursorTo(59,12);
scanf("%d",&a);
CreateSmWindow("彈球游戲\n",0,0,40,28,13,0);
MoveCursorTo(32,12);
SetTextColor(9,0);
printf("★游戲開始★");
sleep(1200);
CreateSmWindow("彈球游戲",0,0,40,28,13,0);
MainLoop();
}
我剛做我完的彈球游戲,但是不是很好玩1你看一下```呵呵
㈦ 適合初學者的24點游戲C語言源代碼
關於二十四點游戲的編程思路與基本演算法
漫長的假期對於我來說總是枯燥無味的，閑來無聊便和同學玩起童年時經常玩的二十四點牌游戲來。此游戲說來簡單，就是利用加減乘除以及括弧將給出的四張牌組成一個值為24的表達式。但是其中卻不乏一些有趣的題目，這不，我們剛玩了一會兒，便遇到了一個難題——3、6、6、10（其實後來想想，這也不算是個太難的題，只是當時我們的腦筋都沒有轉彎而已，呵呵）。
問題既然出現了，我們當然要解決。冥思苦想之際，我的腦中掠過一絲念頭——何不編個程序來解決這個問題呢？文曲星中不就有這樣的程序嗎？所以這個想法應該是可行。想到這里我立刻開始思索這個程序的演算法，最先想到的自然是窮舉法（後來發現我再也想不到更好的方法了，悲哀呀，呵呵），因為在這學期我曾經寫過一個小程序——計算有括弧的簡單表達式。只要我能編程實現四個數加上運算符號所構成的表達式的窮舉，不就可以利用這個計算程序來完成這個計算二十四點的程序嗎？確定了這個思路之後，我開始想這個問題的細節。
首先窮舉的可行性問題。我把表達式如下分成三類——
1、 無括弧的簡單表達式。
2、 有一個括弧的簡單表達式。
3、 有兩個括弧的較復4、 雜表達式。
窮舉的開始我對給出的四個數進行排列，其可能的種數為4*3*2*1=24。我利用一個嵌套函數實現四個數的排列，演算法如下:
/* ans[] 用來存放各種排列組合的數組 */
/* c[] 存放四張牌的數組 */
/* k[] c[]種四張牌的代號，其中k[I]=I+1。
用它來代替c[]做處理，考慮到c[]中有可能出現相同數的情況 */
/* kans[] 暫存生成的排列組合 */
/* j 嵌套循環的次數 */
int fans(c,k,ans,kans,j)
int j,k[],c[];char ans[],kans[];
{ int i,p,q,r,h,flag,s[4],t[4][4];
for(p=0,q=0;p<4;p++)
{ for(r=0,flag=0;r if(k[p]!=kans[r]) flag++;
if(flag==j) t[j][q++]=k[p];
}
for(s[j]=0;s[j]<4-j;s[j]++)
{ kans[j]=t[j][s[j>;
if(j==3) { for(h=0;h<4;h++)
ans[2*h]=c[kans[h]-1]; /* 調整生成的排列組合在最終的表
達式中的位置 */
for(h=0;h<3;h++)
symbol(ans,h); /* 在表達式中添加運算符號 */
}
else { j++;
fans(c,k,ans,kans,j);
j--;
}
}
}
正如上面函數中提到的，在完成四張牌的排列之後，在表達式中添加運算符號。由於只有四張牌，所以只要添加三個運算符號就可以了。由於每一個運算符號可重復，所以計算出其可能的種數為4*4*4=64種。仍然利用嵌套函數實現添加運算符號的窮舉，演算法如下:
/* ans[],j同上。sy[]存放四個運算符號。h為表達式形式。*/
int sans(ans,sy,j,h)
char ans[],sy[];int j,h;
{ int i,p,k[3],m,n; char ktans[20];
for(k[j]=0;k[j]<4;k[j]++)
{ ans[2*j+1]=sy[k[j>; /* 剛才的四個數分別存放在0、2、4、6位
這里的三個運算符號分別存放在1、3、5位*/
if(j==2)
{ ans[5]=sy[k[j>;
/* 此處根據不同的表達式形式再進行相應的處理 */
}
else { j++; sans(ans,sy,j--,h); }
}
}
好了，接下來我再考慮不同表達式的處理。剛才我已經將表達式分為三類，是因為添加三個括弧對於四張牌來說肯定是重復的。對於第一種，無括弧自然不用另行處理；而第二種情況由以下代碼可以得出其可能性有六種，其中還有一種是多餘的。
for(m=0;m<=4;m+=2)
for(n=m+4;n<=8;n+=2)
這個for循環給出了添加一個括弧的可能性的種數，其中m、n分別為添加在表達式中的左右括弧的位置。我所說的多餘的是指m=0，n=8，也就是放在表達式的兩端。這真是多此一舉，呵呵！最後一種情況是添加兩個括弧，我分析了一下，發現只可能是這種形式才不會是重復的——（a b）(c d)。為什麼不會出現嵌套括弧的情況呢？因為如果是嵌套括弧，那麼外面的括弧肯定是包含三個數字的（四個沒有必要），也就是說這個括弧裡麵包含了兩個運算符號，而這兩個運算符號是被另外一個括弧隔開的。那麼如果這兩個運算符號是同一優先順序的，則肯定可以通過一些轉換去掉括弧（你不妨舉一些例子來試試），也就是說這一個括弧沒有必要；如果這兩個運算符號不是同一優先順序，也必然是這種形式((a+-b)*/c)。而*和/在這幾個運算符號中優先順序最高，自然就沒有必要在它的外面添加括弧了。
綜上所述，所有可能的表達式的種數為24*64*（1+6+1）=12288種。哈哈，只有一萬多種可能性（這其中還有重復），這對於電腦來說可是小case喲！所以，對於窮舉的可行性分析和實現也就完成了。
接下來的問題就是如何對有符號的簡單表達式進行處理。這是棧的一個著名應用，那麼什麼是棧呢？棧的概念是從日常生活中貨物在貨棧種的存取過程抽象出來的，即最後存放入棧的貨物（堆在靠出口處）先被提取出去，符合「先進後出，後進先出」的原則。這種結構猶如子彈夾。
在棧中，元素的插入稱為壓入（push）或入棧，元素的刪除稱為彈出（pop）或退棧。
棧的基本運算有三種，其中包括入棧運算、退棧運算以及讀棧頂元素，這些請參考相關數據結構資料。根據這些基本運算就可以用數組模擬出棧來。
那麼作為棧的著名應用，表達式的計算可以有兩種方法。
第一種方法——
首先建立兩個棧，操作數棧OVS和運算符棧OPS。其中，操作數棧用來記憶表達式中的操作數，其棧頂指針為topv，初始時為空，即topv=0；運算符棧用來記憶表達式中的運算符，其棧頂指針為topp，初始時，棧中只有一個表達式結束符，即topp=1，且OPS（1）=『；』。此處的『；』即表達式結束符。
然後自左至右的掃描待處理的表達式，並假設當前掃描到的符號為W，根據不同的符號W做如下不同的處理：
1、 若W為操作數
2、 則將W壓入操作數棧OVS
3、 且繼續掃描下一個字元
4、 若W為運算符
5、 則根據運算符的性質做相應的處理：
(1)、若運算符為左括弧或者運算符的優先順序大於運算符棧棧頂的運算符(即OPS(top)),則將運算符W壓入運算符棧OPS，並繼續掃描下一個字元。
(2)、若運算符W為表達式結束符『；』且運算符棧棧頂的運算符也為表達式結束符（即OPS(topp)=』;』），則處理過程結束，此時，操作數棧棧頂元素（即OVS（topv））即為表達式的值。
(3)、若運算符W為右括弧且運算符棧棧頂的運算符為左括弧（即OPS（topp）=』(『)，則將左括弧從運算符棧談出，且繼續掃描下一個符號。
(4)、若運算符的右不大於運算符棧棧頂的運算符（即OPS(topp)），則從操作數棧OVS中彈出兩個操作數，設先後彈出的操作數為a、b，再從運算符棧OPS中彈出一個運算符，設為+，然後作運算a+b,並將運算結果壓入操作數棧OVS。本次的運算符下次將重新考慮。
第二種方法——
首先對表達式進行線性化，然後將線性表達式轉換成機器指令序列以便進行求值。
那麼什麼是表達式的線性化呢？人們所習慣的表達式的表達方法稱為中綴表示。中綴表示的特點是運算符位於運算對象的中間。但這種表示方式，有時必須藉助括弧才能將運算順序表達清楚，而且處理也比較復雜。
1929年，波蘭邏輯學家Lukasiewicz提出一種不用括弧的邏輯符號體系，後來人們稱之為波蘭表示法（Polish notation）。波蘭表達式的特點是運算符位於運算對象的後面，因此稱為後綴表示。在對波蘭表達式進行運算，嚴格按照自左至右的順序進行。下面給出一些表達式及其相應的波蘭表達式。
表達式 波蘭表達式
A-B AB-
（A-B）*C+D AB-C*D+
A*（B+C/D）-E*F ABCD/+*EF*-
（B+C）/（A-D） BC+AD-/
OK，所謂表達式的線性化是指將中綴表達的表達式轉化為波蘭表達式。對於每一個表達式，利用棧可以把表達式變換成波蘭表達式，也可以利用棧來計算波蘭表達式的值。
至於轉換和計算的過程和第一種方法大同小異，這里就不再贅述了。
下面給出轉換和計算的具體實現程序——
/* first函數給出各個運算符的優先順序，其中=為表達式結束符 */
int first(char c)
{ int p;
switch(c)
{ case '*': p=2; break;
case '/': p=2; break;
case '+': p=1; break;
case '-': p=1; break;
case '(': p=0; break;
case '=': p=-1; break;
}
return(p);
}
/* 此函數實現中綴到後綴的轉換 */
/* M的值宏定義為20 */
/* sp[]為表達式數組 */
int mid_last()
{ int i=0,j=0; char c,sm[M];
c=s[0]; sm[0]='='; top=0;
while(c!='\0')
{ if(islower(c)) sp[j++]=c;
else switch(c)
{ case '+':
case '-':
case '*':
case '/': while(first(c)<=first(sm[top]))
sp[j++]=sm[top--];
sm[++top]=c; break;
case '(': sm[++top]=c; break;
case ')': while(sm[top]!='(')
sp[j++]=sm[top--];
top--; break;
default :return(1);
}
c=s[++i];
}
while(top>0) sp[j++]=sm[top--];
sp[j]='\0'; return(0);
}
/* 由後綴表達式來計算表達式的值 */
int calc()
{ int i=0,sm[M],tr; char c;
c=sp[0]; top=-1;
while(c!='\0')
{ if(islower(c)) sm[++top]=ver[c-'a'];/*在轉換過程中用abcd等來代替數，
這樣才可以更方便的處理非一位數，
ver數組中存放著這些字母所代替的數*/
else switch(c)
{ case '+': tr=sm[top--]; sm[top]+=tr; break;
case '-': tr=sm[top--]; sm[top]-=tr; break;
case '*': tr=sm[top--]; sm[top]*=tr; break;
case '/': tr=sm[top--];sm[top]/=tr;break;
default : return(1);
}
c=sp[++i];
}
if(top>0) return(1);
else { result=sm[top]; return(0); }
}
這樣這個程序基本上就算解決了，回過頭來拿這個程序來算一算文章開始的那個問題。哈哈，算出來了，原來如此簡單——（6-3）*10-6=24。
最後我總結了一下這其中容易出錯的地方——
1、 排列的時候由於一個數只能出現一次， 所以必然有一個判斷語句。但是用什麼來判斷，用大小顯然不行，因為有可能這四個數中有兩個或者以上的數是相同的。我的方法是給每一個數設置一個代號，在排列結束時，通過這個代號找到這個數。
2、在應用嵌套函數時，需仔細分析程序的執行過程，並對個別變數進行適當的調整（如j的值）,程序才能正確的執行。
3、在分析括弧問題的時候要認真仔細，不要錯過任何一個可能的機會，也要盡量使程序變得簡單一些。不過我的分析可能也有問題，還請高手指點。
4、在用函數對一個數組進行處理的時候，一定要注意如果這個數組還需要再應用，就必須將它先保存起來，否則會出錯，而且是很嚴重的錯誤。
5、在處理用戶輸入的表達式時，由於一個十位數或者更高位數是被分解成各位數存放在數組中，所以需對它們進行處理，將它們轉化成實際的整型變數。另外，在轉化過程中，用一個字母來代替這個數，並將這個數存在一個數組中，且它在數組中的位置和代替它的這個字母有一定的聯系，這樣才能取回這個數。
6、由於在窮舉過程難免會出現計算過程中有除以0的計算，所以我們必須對calc函數種對於除的運算加以處理，否則程序會因為出錯而退出（Divide by 0）。
7、最後一個問題，本程序尚未解決。對於一些比較著名的題目，本程序無法解答。比如說5、5、5、1或者8、8、3、3。這是由於這些題目在計算的過程用到了小數，而本程序並沒有考慮到小數。
㈧ 就C語言中 猜拳游戲的代碼
這是一個簡單的猜拳游戲（剪子包子錘），讓你與電腦對決。你出的拳頭由你自己決定，電腦則隨機出拳，最後判斷勝負。
下面的代碼會實現一個猜拳游戲，讓你與電腦對決。你出的拳頭由你自己決定，電腦則隨機出拳，最後判斷勝負。
啟動程序後，讓用戶出拳，截圖：
用戶出拳，顯示對決結果：截圖：
代碼實現：
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
char gamer; // 玩家出拳
int computer; // 電腦出拳
int result; // 比賽結果
// 為了避免玩一次游戲就退出程序，可以將代碼放在循環中
while (1){
printf("這是一個猜拳的小游戲，請輸入你要出的拳頭：\n");
printf("A:剪刀\nB:石頭\nC:布\nD:不玩了\n");
scanf("%c%*c",&gamer);
switch (gamer){
case 65: //A
case 97: //a
gamer=4;
break;
case 66: //B
case 98: //b
gamer=7;
break;
case 67: //C
case 99: //c
gamer=10;
break;
case 68: //D
case 100: //d
return 0;
default:
printf("你的選擇為 %c 選擇錯誤,退出...\n",gamer);
getchar();
system("cls"); // 清屏
return 0;
break;
}
srand((unsigned)time(NULL)); // 隨機數種子
computer=rand()%3; // 產生隨機數並取余，得到電腦出拳
result=(int)gamer+computer; // gamer 為 char 類型，數學運算時要強制轉換類型
printf("電腦出了");
switch (computer)
{
case 0:printf("剪刀\n");break; //4 1
case 1:printf("石頭\n");break; //7 2
case 2:printf("布\n");break; //10 3
}
printf("你出了");
switch (gamer)
{
case 4:printf("剪刀\n");break;
case 7:printf("石頭\n");break;
case 10:printf("布\n");break;
}
if (result==6||result==7||result==11) printf("你贏了!");
else if (result==5||result==9||result==10) printf("電腦贏了!");
else printf("平手");
system("pause>nul&&cls"); // 暫停並清屏
}
return 0;
}
代碼分析
1) 首先，我們需要定義3個變數來儲存玩家出的拳頭(gamer)、電腦出的拳頭(computer)和最後的結果(result)，然後給出文字提示，讓玩家出拳。
接下來接收玩家輸入：
scanf("%c%*c",&gamer);
㈨ 教你如何使用C語言編寫簡單小游戲
編寫程序，實現如下表所示的5-魔方陣。
17
24
1
8
15
23
5
7
14
16
4
6
13
20
22
10
12
19
21
3
11
18
25
2
9
5-魔方陣
問題分析
所謂「n-魔方陣」，指的是使用1〜n2共n2個自然數排列成一個n×n的方陣，其中n為奇數；該方陣的每行、每列及對角線元素之和都相等，並為一個只與n有關的常數，該常數為n×(n2+1)/2。
例如5-魔方陣，其第一行、第一列及主對角線上各元素之和如下：
第一行元素之和：17+24+1+8+15=65
第一列元素之和：17+23+4+10+11=65
主對角線上元素之和：17+5+13+21+9=65
而
n×(n2+1)/2=5×(52+1)/2=65
可以驗證，5-魔方陣中其餘各行、各列及副對角線上的元素之和也都為65。
假定陣列的行列下標都從0開始，則魔方陣的生成方法為：在第0行中間置1，對從2開始的其餘n2-1個數依次按下列規則存放：
(1)
假定當前數的下標為(i，j)，則下一個數的放置位置為當前位置的右上方，即下標為(i-1，j+1)的位置。
(2)
如果當前數在第0行，即i-1小於0，則將下一個數放在最後一行的下一列上，即下標為(n-1，j+1)的位置。
(3)
如果當前數在最後一列上，即j+1大於n-1，則將下一個數放在上一行的第一列上，即下標為(i-1，0)的位置。
(4)
如果當前數是n的倍數，則將下一個數直接放在當前位置的正下方，即下標為(i+1，j）的位置。
演算法設計
在設計演算法時釆用了下面一些方法：
定義array()函數，array()函數的根據輸入的n值，生成並顯示一個魔方陣，當發現n不是奇數時，就加1使之成為奇數。
使用動態內存分配與釋放函數malloc()與free()，在程序執行過程中動態分配與釋放內存，這樣做的好處是使代碼具有通用性，同時提高內存的使用率。
在分配內存時還要注意，由於一個整型數要佔用兩個內存，因此，如果魔方陣中要存放的數有max個，則分配內存時要分配2*max個單元，從而有malloc(max+max)。在malloc()函數中使用max+max而不是2*max是考慮了程序運行的性能。
顯然應該使用二維數組來表示魔方陣，但雖然數組是二維形式的，而由於內存是一維線性的，因此在存取數組元素時，要將雙下標轉換為單個索引編號。在程序中直接定義了指針變數來指向數組空間，即使用malloc()函數分配的內存。
㈩ C語言小游戲
貪吃蛇的源代碼
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<conio.h>
typedef struct snake
{
int a;
int b;
struct snake *u;
struct snake *n;
}snake,*snake1;
typedef struct food
{
int a;
int b;
}food;
void main()
{
char c,c0 = 'd';
int i,j,k,n=1,t,at;
snake p,q;
snake *dd,*dd0,*dd1,*dd2;
food f;
srand(time(NULL));
p.u = NULL;
p.n = &q;
p.a = 5;p.b = 6;q.a = 5;q.b = 5;
q.u = &p;q.n = NULL;
dd=dd2= &q;
f.a=(rand()%15+1);
f.b=(rand()%15+1);
while(1)
{
srand(time(NULL));
system("cls");
for(i = 0;i < 17;i ++)
{
for(j = 0; j < 17;j++)
{
if(i == 0 )
printf("▁");
else if(i == 16)
printf("▔");
else if(j == 0)
printf("▕");
else if(j == 16)
printf("▏");
else if(i == p.a && j == p.b)
printf("■");
else if(i == f.a && j == f.b)
printf("★");
else
{
t = 0;
dd = dd2;
for(k = 0; k < n ;k++)
{
if(i == dd->a && j == dd->b)
{
printf("□");
t = 1;
break;
}
dd = dd->u;
}
if(t == 0)
printf(" ");
}
}printf("\n");
}
at = 0;
dd =dd2;
for(i=0;i<n;i++)
{
if(p.a == dd->a && p.b == dd->b)
{
printf("game over!!\n");
exit(0);
}
dd = dd->u;
}
if(p.a == f.a && p.b == f.b)
{
dd = dd2;
at =1;
f.a = (rand()%15+1);
f.b = (rand()%15+1);
for(i=0;i<n;i++)
{
if(f.a == dd->a && f.b == dd->b)
{
f.a = dd2->a;
f.b = dd2->b;
break;
}
}
n++;
}
if(kbhit())
{
c = getch();
dd = dd2;
if(c == 'w' && c0 != 's')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
if(p.a == 1)
p.a = 15;
else
p.a = (p.a-1)%15;
}
else if(c == 's' && c0 != 'w')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
p.a = (p.a%15)+1;
}
else if(c == 'a' && c0 != 'd')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
if(p.b == 1)
p.b = 15;
else
p.b = (p.b-1)%15;
}
else if(c == 'd' && c0 != 'a')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
p.b = (p.b%15)+1;
}
else
{
goto qq;
}
c0 = c;
}
else
{
qq: if(c0 == 'w')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
if(p.a == 1)
p.a = 15;
else
p.a=(p.a-1)%15;
}
else if(c0 == 's')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
p.a=(p.a%15)+1;
}
else if(c0 == 'a')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
if(p.b == 1)
p.b = 15;
else
p.b=(p.b-1)%15;
}
else if(c0 == 'd')
{
if(at == 1)
{
dd0 =(snake1)malloc(sizeof(snake));
dd0->a = dd2->a;dd0->b = dd2->b;
dd0->n = NULL;dd0->u = dd2;
dd2=dd0;
}
dd = dd2;
for(i = 0; i<n ; i++)
{
dd1 = dd->u;
dd->b = dd1->b;
dd->a = dd1->a;
dd = dd->u;
}
p.b=(p.b%15)+1;
}
}
fflush(stdin);
dd = &q;
_sleep(0);
}
}