俄罗斯方块正在进行时，求高手帮着看看哪里错了，附思路

漠水

（1）建立一个二维数组利用结构体space->a[][]作为存储空间，首次初始化令数组空间存储为0，当存储为1时显示
（2）应用结构体变量存储方块在矩阵中的位置p->a1,p->a2和偏移p->x,p->y
（3）利用链表节点作为方块，判断遍历，输出和判断方块的位置和是否碰底或接触
（4）接触后到达底部或者即将碰撞则直接存储入二维数组，利用横坐标p->a+p->x和纵坐标p->a2+p->y判断

问题是，碰底后消失？看不出问题在哪里，(问题应该在judge函数中)求解答？第一个是显示的界面，第二个是测试的界面界面，发现测试的结果是
循环停止在判断条件成立的时候，求解释
已完成旋转（进行），左右下的位移，下面是显示界面代码

1. #include<stdio.h>
   
2. #include<conio.h>
   
3. #include<malloc.h>
   
4. #include<graphics.h>
   
5. #define NULL 0
   
6. #define kuan 15
   
7. #define gao 30
   
8. 
   
9. typedef struct h //构建节点，a1,a2代表在矩阵中的坐标(a1,a2),x,y代表位移
   
10. {
    
11. int a1,a2,x,y;
    
12. struct h *next;
    
13. }h;
    
14. 
    
15. typedef struct space //定义空间
    
16. {
    
17. int a[kuan][gao];
    
18. }space;
    
19. 
    
20. 
    
21. space *creatspace() //创建初始化空间，a[30][15]=0
    
22. {
    
23. int x,y;
    
24. space *p;
    
25. p=(space *)malloc(sizeof(space));
    
26. for(x=0;x<kuan;x++)
    
27. for(y=0;y<gao;y++)
    
28. p->a[x][y]=0;
    
29. return p;
    
30. }
    
31. 
    
32. 
    
33. void out(space *p) //空间输出
    
34. {
    
35. int x,y;
    
36. for(x=0;x<kuan;x++)
    
37. for(y=0;y<gao;y++)
    
38. if(p->a[x][y]==1)
    
39. {
    
40. setfillcolor(YELLOW);
    
41. bar(x*10,y*10,x*10+10,y*10+10);
    
42. }
    
43. }
    
44. 
    
45. 
    
46. h *creat(int n)
    
47. {
    
48. h *head,*p1,*p2,*p3,*p4;
    
49. head=(h*)malloc(sizeof(h));
    
50. p2=(h*)malloc(sizeof(h));
    
51. p3=(h*)malloc(sizeof(h));
    
52. p4=(h*)malloc(sizeof(h));
    
53. p1=head;
    
54. p1->next=p2;
    
55. p2->next=p3;
    
56. p3->next=p4;
    
57. p4->next=NULL;
    
58. 
    
59. if(n==1) //判定显示什么样的方块--|
    
60. {
    
61. p1->a1=0;
    
62. p1->a2=0;
    
63. p2->a1=0;
    
64. p2->a2=1;
    
65. p3->a1=0;
    
66. p3->a2=2;
    
67. p4->a1=1;
    
68. p4->a2=2;
    
69. p1->x=p2->x=p3->x=p4->x=p1->y=p2->y=p3->y=p4->y=2;
    
70. }
    
71. 
    
72. return head;
    
73. }
    
74. 
    
75. 
    
76. 
    
77. void xian(h *head) //显示
    
78. {
    
79. h *p;
    
80. p=head;
    
81. while(p!=0)
    
82. {
    
83. setfillcolor(YELLOW);
    
84. bar((p->a1+p->x)*10,(p->a2+p->y)*10,(p->a1+p->x)*10+10,(p->a2+p->y)*10+10);
    
85. p=p->next;
    
86. }
    
87. }
    
88. 
    
89. 
    
90. void xiao(h *head) //消失
    
91. {
    
92. h *p;
    
93. p=head;
    
94. while(p!=0)
    
95. {
    
96. setfillcolor(BLACK);
    
97. bar((p->a1+p->x)*1,(p->a2+p->y)*10,(p->a1+p->x)*10+10,(p->a2+p->y)*10+10);
    
98. p=p->next;
    
99. }
    
100. }
     
101. 
     
102. 
     
103. void xuan(h *head) //旋转
     
104. {
     
105. 
     
106. h*p;
     
107. int a;
     
108. p=head;
     
109. while(p!=0)
     
110. {
     
111. 
     
112. a=p->a1;
     
113. p->a1=2-p->a2;
     
114. p->a2=a;
     
115. p=p->next;
     
116. 
     
117. }
     
118. }
     
119. 
     
120. //方向开始
     
121. 
     
122. void left(h *head)
     
123. {
     
124. h *p;
     
125. p=head;
     
126. while(p!=NULL)
     
127. {
     
128. p->x=p->x-1;
     
129. p=p->next;
     
130. }
     
131. }
     
132. 
     
133. void right(h *head)
     
134. { h *p;
     
135. p=head;
     
136. while(p!=NULL)
     
137. {
     
138. p->x=p->x+1;
     
139. p=p->next;
     
140. }
     
141. }
     
142. 
     
143. void down(h *head)
     
144. { h *p;
     
145. p=head;
     
146. while(p!=NULL)
     
147. {
     
148. p->y=p->y+1;
     
149. p=p->next;
     
150. }
     
151. }
     
152. //方向结束
     
153. 
     
154. 
     
155. int judge(space *p,h *head) //判定方块是否到底，交接存储，将方块的横纵坐标存入存储空间space中
     
156. {
     
157. int e=0;
     
158. h *q;
     
159. q=head;
     
160. while(q!=NULL)
     
161. {
     
162. if(p->a[q->a1+q->x][q->a2+(q->y)+1]==1||(q->a2+q->y)==gao) e=1; //直接y的下一个已经有值或者到底了
     
163. 
     
164. q=q->next;
     
165. }
     
166. 
     
167. 
     
168. if(e==1)
     
169. {
     
170. q=head;
     
171. while(q!=NULL)
     
172. {
     
173. p->a[q->a1+q->x][q->a2+q->y]=1;
     
174. }
     
175. }
     
176. return e;
     
177. }
     
178. 
     
179. 
     
180. void main()
     
181. {
     
182. int a[4][4];
     
183. int e=0;
     
184. space *p;
     
185. p=creatspace();
     
186. h *head; //初始化开始
     
187. initgraph(kuan*10,gao*10); //建立图像
     
188. 
     
189. head=creat(1); // 创建新的方块
     
190. while(1)
     
191. { xian(head);
     
192. Sleep(500);
     
193. xiao(head);
     
194. if(!kbhit())
     
195. {
     
196. down(head);
     
197. }
     
198. else
     
199. {
     
200. 
     
201. if(getch()==119) //w键
     
202. {
     
203. xuan(head);
     
204. }
     
205. down(head); //无论是否键入都要向下一格
     
206. } //else结束
     
207. 
     
208. e=judge(p,head);
     
209. if(e==1)
     
210. {
     
211. head=creat(1);
     
212. e=0;
     
213. }
     
214. out(p);
     
215. } //while结束
     
216. 
     
217. closegraph();
     
218. 
     
219. }

复制代码

测试界面

1. #include<stdio.h>
   
2. #include<conio.h>
   
3. #include<malloc.h>
   
4. #include<graphics.h>
   
5. #define NULL 0
   
6. #define kuan 15
   
7. #define gao 30
   
8. 
   
9. typedef struct h //构建节点，a1,a2代表在矩阵中的坐标(a1,a2),x,y代表位移
   
10. {
    
11. int a1,a2,x,y;
    
12. struct h *next;
    
13. }h;
    
14. 
    
15. h *creat(int n)
    
16. {
    
17. h *head,*p1,*p2,*p3,*p4;
    
18. head=(h*)malloc(sizeof(h));
    
19. p2=(h*)malloc(sizeof(h));
    
20. p3=(h*)malloc(sizeof(h));
    
21. p4=(h*)malloc(sizeof(h));
    
22. p1=head;
    
23. p1->next=p2;
    
24. p2->next=p3;
    
25. p3->next=p4;
    
26. p4->next=NULL;
    
27. 
    
28. if(n==1) //判定显示什么样的方块--|
    
29. {
    
30. p1->a1=0;
    
31. p1->a2=0;
    
32. p2->a1=0;
    
33. p2->a2=1;
    
34. p3->a1=0;
    
35. p3->a2=2;
    
36. p4->a1=1;
    
37. p4->a2=2;
    
38. p1->x=p2->x=p3->x=p4->x=p1->y=p2->y=p3->y=p4->y=2;
    
39. }
    
40. 
    
41. return head;
    
42. }
    
43. 
    
44. 
    
45. 
    
46. 
    
47. 
    
48. 
    
49. void xuan(h *head) //旋转
    
50. {
    
51. 
    
52. h*p;
    
53. int a;
    
54. p=head;
    
55. while(p!=0)
    
56. {
    
57. 
    
58. a=p->a1;
    
59. p->a1=2-p->a2;
    
60. p->a2=a;
    
61. p=p->next;
    
62. 
    
63. }
    
64. }
    
65. 
    
66. //方向开始
    
67. 
    
68. 
    
69. 
    
70. void down(h *head)
    
71. { h *p;
    
72. p=head;
    
73. while(p!=NULL)
    
74. {
    
75. p->y=p->y+1;
    
76. printf("p->a1=%d p->a2=%d p->x=%d p->y=%d\n",p->a1,p->a2,p->x,p->y);
    
77. p=p->next;
    
78. 
    
79. }
    
80. }
    
81. //方向结束
    
82. 
    
83. typedef struct space //定义空间
    
84. {
    
85. int a[kuan][gao];
    
86. }space;
    
87. 
    
88. 
    
89. space *creat() //创建初始化空间，a[30][15]=0
    
90. {
    
91. int x,y;
    
92. space *p;
    
93. p=(space *)malloc(sizeof(space));
    
94. for(x=0;x<kuan;x++)
    
95. for(y=0;y<gao;y++)
    
96. p->a[x][y]=0;
    
97. return p;
    
98. }
    
99. 
    
100. 
     
101. void out(space *p) //空间输出
     
102. {
     
103. int x,y;
     
104. for(x=0;x<kuan;x++)
     
105. for(y=0;y<gao;y++)
     
106. if(p->a[x][y]==1)
     
107. {
     
108. printf("p->a[%d][%d]=%d",x,y,p->a[x][y]);
     
109. }
     
110. }
     
111. 
     
112. 
     
113. int judge(space *p,h *head) //判定方块是否到底，交接存储，将方块的横纵坐标存入存储空间space中
     
114. {
     
115. int e=0;
     
116. h *q;
     
117. q=head;
     
118. while(q!=NULL)
     
119. {
     
120. if(p->a[q->a1+q->x][q->a2+(q->y)+1]==1||(q->a2+q->y)==gao) e=1; //直接y的下一个已经有值或者到底了
     
121. 
     
122. q=q->next;
     
123. }
     
124. 
     
125. 
     
126. if(e==1)
     
127. {
     
128. q=head;
     
129. while(q!=NULL)
     
130. {
     
131. p->a[q->a1+q->x][q->a2+q->y]=1;
     
132. }
     
133. }
     
134. return e;
     
135. }
     
136. 
     
137. 
     
138. void main()
     
139. {
     
140. 
     
141. int e=0;
     
142. space *p;
     
143. p=creat();
     
144. h *head; //初始化开始
     
145. head=creat(1); // 创建新的方块
     
146. while(1)
     
147. {
     
148. Sleep(1000);
     
149. if(!kbhit())
     
150. {
     
151. down(head);
     
152. }
     
153. else
     
154. {
     
155. 
     
156. if(getch()==119) //w键
     
157. {
     
158. xuan(head);
     
159. }
     
160. down(head); //无论是否键入都要向下一格
     
161. } //else结束
     
162. 
     
163. e=judge(p,head);
     
164. if(e==1)
     
165. {
     
166. head=creat(1);
     
167. e=0;
     
168. }
     
169. out(p);
     
170. printf("\n");
     
171. } //while结束
     
172. 
     
173. 
     
174. 
     
175. }

复制代码

向往青莲

汗。。。。。

漠水

一个q=q->next忘记加叫让我卡了一天，悲催的试调啊

漠水

judge函数中第二个循环if（e==1）中后面忘记q=q->next

yuzhouliu2000

我草，你写的注释太简单了，自己能看懂吗

漠水

yuzhouliu2000 发表于 2014-11-12 13:52
我草，你写的注释太简单了，自己能看懂吗

呃，问题已经被我自己解决了，注释基本上都在最前面啊，就是怕你们看不懂所以才把基本思路给说了，其实变量就是2个结构体，一个是存储空间space，存储二维数组的，一个是用来链表用来存储方块的，下面是已经修改过的代码

1. #include<stdio.h>
   
2. #include<conio.h>
   
3. #include<malloc.h>
   
4. #include<graphics.h>
   
5. #define NULL 0
   
6. #define kuan  15
   
7. #define gao   30
   
8. 
   
9. typedef struct h        //构建节点，a1,a2代表在矩阵中的坐标(a1,a2),x,y代表位移
   
10. {
    
11. int a1,a2,x,y;            
    
12. struct h *next;
    
13. }h;
    
14. 
    
15. typedef struct space         //定义空间
    
16. {
    
17.         int        a[kuan][gao];
    
18. }space;
    
19. 
    
20. 
    
21. space *creatspace()               //创建初始化空间，a[30][15]=0
    
22. {
    
23.         int x,y;
    
24.         space *p;
    
25.         p=(space *)malloc(sizeof(space));
    
26.         for(x=0;x<kuan;x++)
    
27.         for(y=0;y<gao;y++)
    
28.                 p->a[x][y]=0;
    
29.         return p;
    
30. }
    
31. 
    
32. 
    
33. void out(space *p)          //空间输出
    
34. {
    
35.         int x,y;
    
36.                 for(x=0;x<kuan;x++)
    
37.                 for(y=0;y<gao;y++)
    
38.                 if(p->a[x][y]==1)
    
39.                 {
    
40.                         setcolor(BLUE);
    
41.                         setfillcolor(YELLOW);
    
42.                         bar(x*10,y*10,x*10+10,y*10+10);
    
43.                 }
    
44. }
    
45. 
    
46. 
    
47. h *creat(int n)
    
48. {
    
49. h *head,*p1,*p2,*p3,*p4;
    
50. head=(h*)malloc(sizeof(h));
    
51. p2=(h*)malloc(sizeof(h));
    
52. p3=(h*)malloc(sizeof(h));
    
53. p4=(h*)malloc(sizeof(h));
    
54. p1=head;
    
55. p1->next=p2;
    
56. p2->next=p3;
    
57. p3->next=p4;
    
58. p4->next=NULL;
    
59. 
    
60.         if(n==1)                //判定显示什么样的方块--|
    
61.         {
    
62.         p1->a1=0;
    
63.         p1->a2=0;
    
64.         p2->a1=0;
    
65.         p2->a2=1;
    
66.         p3->a1=0;
    
67.         p3->a2=2;
    
68.         p4->a1=1;
    
69.         p4->a2=2;
    
70.         p1->x=p2->x=p3->x=p4->x=p1->y=p2->y=p3->y=p4->y=2;
    
71.         }
    
72. 
    
73. return head;
    
74. }
    
75. 
    
76. 
    
77. 
    
78. void xian(h *head)                      //显示
    
79. {
    
80.         h *p;
    
81.         p=head;
    
82.         while(p!=0)
    
83.         {
    
84.                 setfillcolor(YELLOW);
    
85.                 bar((p->a1+p->x)*10,(p->a2+p->y)*10,(p->a1+p->x)*10+10,(p->a2+p->y)*10+10);
    
86.                 p=p->next;
    
87.         }
    
88. }
    
89. 
    
90. 
    
91. void xiao(h *head)                      //消失
    
92. {
    
93.         h *p;
    
94.         p=head;
    
95.         while(p!=0)
    
96.         {
    
97.                 setfillcolor(BLACK);
    
98.                 bar((p->a1+p->x)*1,(p->a2+p->y)*10,(p->a1+p->x)*10+10,(p->a2+p->y)*10+10);
    
99.                 p=p->next;
    
100.         }
     
101. }
     
102. 
     
103. 
     
104. void xuan(h *head)                       //旋转
     
105. {
     
106.   
     
107.         h*p;
     
108.         int a;
     
109.         p=head;
     
110.         while(p!=0)
     
111.         {
     
112.                                                
     
113.                 a=p->a1;
     
114.                 p->a1=2-p->a2;
     
115.                 p->a2=a;
     
116.                 p=p->next;
     
117.                
     
118.         }
     
119. }
     
120. 
     
121. //方向开始
     
122. 
     
123. void left(h *head)
     
124. {
     
125.         h *p;
     
126. p=head;
     
127. while(p!=NULL)
     
128. {
     
129. p->x=p->x-1;
     
130. p=p->next;
     
131. }
     
132. }
     
133. 
     
134. void right(h *head)
     
135. { h *p;
     
136. p=head;
     
137. while(p!=NULL)
     
138. {
     
139. p->x=p->x+1;
     
140. p=p->next;
     
141. }
     
142. }
     
143. 
     
144. void down(h *head)
     
145. { h *p;
     
146. p=head;
     
147. while(p!=NULL)
     
148. {
     
149. p->y=p->y+1;
     
150. p=p->next;
     
151. }
     
152. }
     
153. //方向结束
     
154. 
     
155. 
     
156. int judge(space *p,h *head)                   //判定方块是否到底，交接存储，将方块的横纵坐标存入存储空间space中
     
157. {
     
158.         int e=0,n=0;
     
159.         h *q;
     
160.         q=head;
     
161.         while(q!=NULL)
     
162.                 {
     
163.                         if(p->a[q->a1+q->x][q->a2+(q->y)+1]==1||(q->a2+q->y)==gao) //直接y的下一个已经有值或者到底了
     
164.                         {   
     
165.                                 e=1;                    
     
166.                         if(q->a2+q->y==gao)n=1;                                    //到底的话另外在判断
     
167.                         }                           
     
168.                         q=q->next;
     
169. 
     
170.                                                           
     
171.                 }
     
172.                 if(e==1&&n==0)                             //碰边
     
173.                 {
     
174.                         q=head;
     
175.                         printf("有\n");
     
176.                         while(q!=NULL)
     
177.                         {
     
178.                                 p->a[q->a1+q->x][q->a2+q->y]=1;
     
179.        
     
180.                                 q=q->next;
     
181.                         }
     
182.                 }
     
183.                 if(e==1&&n==1)                          //到底
     
184.                 {
     
185.                         q=head;
     
186.                         printf("到底\n");
     
187.                         while(q!=NULL)
     
188.                         {
     
189.                                 p->a[q->a1+q->x][q->a2+q->y-1]=1;
     
190.                        
     
191.                                 q=q->next;
     
192.                         }
     
193.                 }
     
194.                 return e;
     
195. }
     
196. 
     
197. 
     
198. void main()
     
199. {   
     
200.         int e=0;
     
201.         space *p;
     
202.         p=creatspace();
     
203.     h *head;                                                                //初始化开始
     
204.         initgraph(kuan*10,gao*10);                                //建立图像
     
205. 
     
206.         head=creat(1);                                                        //  创建新的方块
     
207.         while(1)       
     
208.         {        xian(head);
     
209.                 Sleep(500);
     
210.                 xiao(head);
     
211.                 if(!kbhit())
     
212.                 {
     
213.                         down(head);
     
214.                 }
     
215.                 else
     
216.                 {
     
217. 
     
218.                         if(getch()==119)       //w键
     
219.                         {
     
220.                                 xuan(head);
     
221.                         }
     
222.                         down(head);         //无论是否键入都要向下一格
     
223.                 }                       //else结束
     
224.        
     
225.                 e=judge(p,head);
     
226.                 if(e==1)
     
227.                 {
     
228.                         head=creat(1);
     
229.                         e=0;
     
230.                 }
     
231.                 out(p);
     
232.         }                                                        //while结束
     
233. 
     
234.     closegraph();
     
235. 
     
236. }

复制代码

漠水

向往青莲 发表于 2014-11-12 13:03
汗。。。。。

诶，我知道代码太长了就没什么太大的机会会有人仔细去看了，然后自己测试解决了，太伤心了，我的100鱼币啊

向往青莲

漠水 发表于 2014-11-12 14:32
诶，我知道代码太长了就没什么太大的机会会有人仔细去看了，然后自己测试解决了，太伤心了，我的100鱼币 ...

噗。。。。。。。。居然给我了。。么么哒。。。

漠水

向往青莲 发表于 2014-11-12 16:10
噗。。。。。。。。居然给我了。。么么哒。。。

点进来了说明你有打算帮着解决，你又是第一个到的，有回复说明你有看，有心就该感谢，鱼币收不回来无所谓，关键是有收获一切都好说

向往青莲

漠水 发表于 2014-11-13 12:35
点进来了说明你有打算帮着解决，你又是第一个到的，有回复说明你有看，有心就该感谢，鱼币收不回来无所谓 ...

恩恩。。本来想帮你看看的。。结果。。一进来。。代码好长。。顿时就给跪了。。

Mikel

鸭蛋，下手太慢。 可恶