卡在俄罗斯方块旋转上了，错在哪里了求指点，谢谢

漠水

1. void xuan(int n,space *p,h *head)
   
2. /*
   
3. 旋转
   
4. n是显示方块的形状 0为长条，1为正方形，2。。。。
   
5. space *p指向一个二维数组a[][]作为存储空间,储存已落地的方块，
   
6. h *head存储方块在矩阵中的位置，如何在矩阵中(a1,a2),控制位移x，y；
   
7. h *head 利用链表存储，遍历旋转
   
8. 通过计算x+a1的坐标判定是否超越左边界，通过判定y+a2-1的坐标来判定是否超越右边界
   
9. 通过判定旋转之后的坐标是否与当前存储空间的位置上冲突（判定当前空间p->a[x+a1][y+a2]是否为1）
   
10. 是则反向旋转，令h *head 重新遍历，反向旋转，回到原位置。
    
11. */
    
12. {
    
13. 
    
14. h*q; //定义一个指针，代替head指针遍历旋转
    
15. q=head;
    
16. int e=0; //判定指针，当需要回到原坐标时的判定
    
17. int a; //a用于数值对换 a=b,b=c,c=a
    
18. int max; //max 用于判定
    
19. if(n<=1)max=3; //显示长条或正方形时矩阵旋转需要a[4][4]
    
20. else max=2; //其他则为a[3][3]
    
21. 
    
22. while(q!=0) //开始旋转
    
23. { a=q->a1;
    
24. q->a1=max-q->a2;
    
25. q->a2=a;
    
26. if(p->a[q->a1+q->x][q->a2+q->y]==1||(q->a1+q->x<0)||(q->a2+q->y>kuan-1))e++;
    
27. /*旋转判定，是否越界或者与存储空间重合,是则判定+1
    
28. 边界宽度宏定义为kuan*/
    
29. q=q->next;
    
30. }
    
31. if(e!=0) //若越界或重合，则开始反向旋转
    
32. { q=head; //重置
    
33. while(q!=0)
    
34. {
    
35. a=q->a1;
    
36. q->a1=q->a2;
    
37. q->a2=max-a;
    
38. q=q->next;
    
39. }
    
40. 
    
41. }
    
42. }
    

复制代码

735899422

a[10][10]至于你说的旋转，我是这样认为的 比如  图中的 “土”字， 首先他们是1，我们就在数组里面循环把它的坐标换一下，如果换完后的坐标 a[i][10]  如果 i<0 那么 就把4个方块的i坐标 +1  如果还有i<1 那么继续+1  如果 i>9那么久-1.不知道能听懂吗？   

漠水

全部代码如下，运行有bug ,旋转会直接卡到边界里面去了，而且有时旋转会失灵，求解释

1. #include<stdio.h>
   
2. #include<conio.h>
   
3. #include<malloc.h>
   
4. #include<graphics.h>
   
5. #define kuan  12
   
6. #define gao   20
   
7. 
   
8. typedef struct h        //构建节点，a1,a2代表在矩阵中的坐标(a1,a2),x,y代表位移
   
9. {
   
10. int a1,a2,x,y;            
    
11. struct h *next;
    
12. }h;
    
13. 
    
14. typedef struct space         //定义空间
    
15. {
    
16.         int        a[kuan][gao];
    
17. }space;
    
18. 
    
19. 
    
20. space *creatspace()               //创建初始化空间，a[30][15]=0
    
21. {
    
22.         int x,y;
    
23.         space *p;
    
24.         p=(space *)malloc(sizeof(space));
    
25.         for(x=0;x<kuan;x++)
    
26.         for(y=0;y<gao;y++)
    
27.                 p->a[x][y]=0;
    
28.         return p;
    
29. }
    
30. 
    
31. 
    
32. void out(space *p)          //空间输出
    
33. {
    
34.         int x,y;
    
35.                 for(x=0;x<kuan;x++)
    
36.                 for(y=0;y<gao;y++)
    
37.                 if(p->a[x][y]==1)
    
38.                 {
    
39.                
    
40.                         setcolor(YELLOW);
    
41.                         bar(x*10,y*10,x*10+10,y*10+10);
    
42.                 }
    
43. }
    
44. 
    
45. void outxiao(space *p)          //空间输出
    
46. {
    
47.         int x,y;
    
48.                 for(x=0;x<kuan;x++)
    
49.                 for(y=0;y<gao;y++)
    
50.                 if(p->a[x][y]==1)
    
51.                 {
    
52.                
    
53.                         setcolor(BLACK);
    
54.                         bar(x*10,y*10,x*10+10,y*10+10);
    
55.                 }
    
56. }
    
57. 
    
58. h *creat(int n)
    
59. {
    
60. h *head,*p1,*p2,*p3,*p4;
    
61. head=(h*)malloc(sizeof(h));
    
62. p2=(h*)malloc(sizeof(h));
    
63. p3=(h*)malloc(sizeof(h));
    
64. p4=(h*)malloc(sizeof(h));
    
65. p1=head;
    
66. p1->next=p2;
    
67. p2->next=p3;
    
68. p3->next=p4;
    
69. p4->next=NULL;
    
70. p1->x=p2->x=p3->x=p4->x=p1->y=p2->y=p3->y=p4->y=2;
    
71. 
    
72.     if(n==0)
    
73.         {
    
74.         p1->a1=1;
    
75.         p1->a2=1;
    
76.         p2->a1=1;
    
77.         p2->a2=2;
    
78.         p3->a1=2;
    
79.         p3->a2=1;
    
80.         p4->a1=2;
    
81.         p4->a2=2;
    
82.        
    
83.        
    
84.        
    
85.        
    
86.         }
    
87.         if(n==1)
    
88.         {
    
89.         p1->a1=0;
    
90.         p1->a2=1;
    
91.         p2->a1=1;
    
92.         p2->a2=1;
    
93.         p3->a1=2;
    
94.         p3->a2=1;
    
95.         p4->a1=3;
    
96.         p4->a2=1;               
    
97.         }
    
98. 
    
99.         if(n==2)                //判定显示什么样的方块--|
    
100.         {
     
101.         p1->a1=0;
     
102.         p1->a2=0;
     
103.         p2->a1=0;
     
104.         p2->a2=1;
     
105.         p3->a1=0;
     
106.         p3->a2=2;
     
107.         p4->a1=1;
     
108.         p4->a2=2;
     
109. 
     
110.         }
     
111. 
     
112.         if(n==3)
     
113.                         {
     
114.         p1->a1=0;
     
115.         p1->a2=1;
     
116.         p2->a1=1;
     
117.         p2->a2=1;
     
118.         p3->a1=1;
     
119.         p3->a2=2;
     
120.         p4->a1=2;
     
121.         p4->a2=1;
     
122. 
     
123.         }
     
124.         if(n==4)
     
125.                         {
     
126.         p1->a1=0;
     
127.         p1->a2=1;
     
128.         p2->a1=1;
     
129.         p2->a2=1;
     
130.         p3->a1=1;
     
131.         p3->a2=2;
     
132.         p4->a1=2;
     
133.         p4->a2=2;
     
134. 
     
135.         }
     
136. 
     
137. 
     
138. 
     
139. return head;
     
140. }
     
141. 
     
142. 
     
143. 
     
144. void xian(h *head)                      //显示
     
145. {
     
146.         h *p;
     
147.         p=head;
     
148.         while(p!=0)
     
149.         {
     
150.                 setfillcolor(GREEN);
     
151.                 bar((p->a1+p->x)*10,(p->a2+p->y)*10,(p->a1+p->x)*10+10,(p->a2+p->y)*10+10);
     
152.                 p=p->next;
     
153.         }
     
154. }
     
155. 
     
156. 
     
157. void xiao(h *head)                      //消失
     
158. {
     
159.         h *p;
     
160.         p=head;
     
161.         while(p!=0)
     
162.         {
     
163.                 setfillcolor(BLACK);
     
164.                 bar((p->a1+p->x)*1,(p->a2+p->y)*10,(p->a1+p->x)*10+10,(p->a2+p->y)*10+10);
     
165.                 p=p->next;
     
166.         }
     
167. }
     
168. 
     
169. 
     
170. void xuan(int n,space *p,h *head)                     
     
171. /*
     
172. 旋转
     
173.   n是显示方块的形状 0为长条，1为正方形，2。。。。
     
174.   space *p指向一个二维数组a[][]作为存储空间,储存已落地的方块，
     
175. h *head存储方块在矩阵中的位置，如何在矩阵中(a1,a2),控制位移x，y；
     
176. h *head 利用链表存储，遍历旋转
     
177. 通过计算x+a1的坐标判定是否超越左边界，通过判定y+a2-1的坐标来判定是否超越右边界
     
178. 通过判定旋转之后的坐标是否与当前存储空间的位置上冲突（判定当前空间p->a[x+a1][y+a2]是否为1）
     
179.    是则反向旋转，令h *head 重新遍历，反向旋转，回到原位置。
     
180.          */
     
181. {
     
182.   
     
183.         h*q;              //定义一个指针，代替head指针遍历旋转
     
184.         q=head;
     
185.         int e=0;          //判定指针，当需要回到原坐标时的判定
     
186.         int a;             //a用于数值对换 a=b,b=c,c=a
     
187.         int max;            //max 用于判定
     
188.         if(n<=1)max=3;      //显示长条或正方形时矩阵旋转需要a[4][4]
     
189.         else max=2;                //其他则为a[3][3]
     
190.        
     
191.         while(q!=0)       //开始旋转
     
192.         {        a=q->a1;
     
193.                 q->a1=max-q->a2;
     
194.                 q->a2=a;
     
195.                 if(p->a[q->a1+q->x][q->a2+q->y]==1||(q->a1+q->x<0)||(q->a2+q->y>kuan))e++;           
     
196.                 /*旋转判定，是否越界或者与存储空间重合,是则判定+1
     
197.                 边界宽度宏定义为kuan*/
     
198.                 q=q->next;               
     
199.         }
     
200.     if(e!=0)        //若显示上面的任意一项，则开始反向旋转
     
201.         {        q=head;                            //重置
     
202.           while(q!=0)
     
203.           {
     
204.                    a=q->a1;
     
205.                 q->a1=q->a2;
     
206.                 q->a2=max-a;
     
207.                 q=q->next;
     
208.           }
     
209.          
     
210.         }
     
211. }
     
212. 
     
213. //方向开始
     
214. 
     
215. void left(space *p,h *head)
     
216. {
     
217.         h *q;
     
218.         int e=1;
     
219.         q=head;
     
220.         while(q!=NULL)      
     
221.         {       
     
222.         if((q->a1+q->x)<=0||p->a[q->a1+q->x-1][q->a2+q->y]==1)      //判定是否碰到边界或本身就存在的方块   
     
223.         {        e=0;break; }     
     
224.     else  q=q->next;
     
225.         }
     
226. 
     
227.         q=head;
     
228.         while(e==1&&q!=NULL)
     
229.         {
     
230.         q->x=q->x-1;
     
231.         q=q->next;
     
232. }
     
233.        
     
234. }
     
235. 
     
236. void right(space *p,h *head)
     
237. {
     
238.         h *q;
     
239.         int e=1;                                                         //e为判定条件
     
240.         q=head;
     
241.         while(q!=NULL)      
     
242.         {       
     
243.         if((q->a1+q->x)>=kuan-1||p->a[q->a1+q->x+1][q->a2+q->y]==1)    //判定是否碰到边界或本身就存在的方块   
     
244.         {        e=0;break; }     
     
245.     else  q=q->next;
     
246.         }
     
247. 
     
248.         q=head;
     
249.         while(e==1&&q!=NULL)
     
250.         {
     
251.         q->x=q->x+1;
     
252.         q=q->next;
     
253. }
     
254.        
     
255. }
     
256. 
     
257. 
     
258. void down(h *head)
     
259. {
     
260. h *p;
     
261. int e=0;
     
262. p=head;
     
263.         while(p!=NULL)
     
264.         {
     
265.         p->y=p->y+1;
     
266.         if(p->a2+p->y==gao)e++;
     
267.         p=p->next;
     
268.         }
     
269. if(e!=0)
     
270. {
     
271.         while(p!=NULL)
     
272.         {
     
273.         p->y=p->y-1;
     
274.         p=p->next;
     
275.         }
     
276. }
     
277. }
     
278. //方向结束
     
279. 
     
280. 
     
281. int judge(space *p,h *head)                   //判定方块是否到底，交接存储，将方块的横纵坐标存入存储空间space中
     
282. {
     
283.         int e=0,n=0;
     
284.         h *q;
     
285.         q=head;
     
286.         while(q!=NULL)
     
287.                 {
     
288.                         if(p->a[q->a1+q->x][q->a2+(q->y)+1]==1||(q->a2+q->y)==gao-1) //直接y的下一个已经有值或者到底了
     
289.                         {   
     
290.                                 e=1;                    
     
291.                         if(q->a2+q->y==gao)n=1;                                    //到底的话另外在判断
     
292.                         }                           
     
293.                         q=q->next;
     
294. 
     
295.                                                           
     
296.                 }
     
297.                 if(e==1&&n==0)                             //碰边
     
298.                 {
     
299.                         q=head;
     
300.                         while(q!=NULL)
     
301.                         {
     
302.                                 p->a[q->a1+q->x][q->a2+q->y]=1;
     
303.        
     
304.                                 q=q->next;
     
305.                         }
     
306.                 }
     
307.                 if(e==1&&n==1)                          //到底
     
308.                 {
     
309.                         q=head;
     
310.                         while(q!=NULL)
     
311.                         {
     
312.                                 p->a[q->a1+q->x][q->a2+q->y-1]=1;
     
313.                        
     
314.                                 q=q->next;
     
315.                         }
     
316.                 }
     
317.                 return e;
     
318. }
     
319. 
     
320. void man(space *p)                //满层判定  函数p包含的是一个二维数组p[x][y],x表示宽度，y表示高度，当a[x][y]为1时,显示
     
321. {
     
322.         int x,y,z,k;                 //z为计数器,k用于存储当前y值
     
323.         z=0;       
     
324.         for(y=gao-1;y>=0;y--,z=0)            //从底层开始判定，每次计数器清零，循环一次之后
     
325.         {
     
326.                 for(x=0;x<kuan;x++)                 //每层判定，当前行为z=15时满值
     
327.                 {
     
328.                         if(p->a[x][y]==1)
     
329.                         {
     
330.                         z=z+1;
     
331.                         }
     
332.                         else break;                      //不为满值则直接跳出进行下一循环
     
333.                 }
     
334. 
     
335.                 if(z==kuan)                            //开始清除
     
336.                 {
     
337.                         for(k=y;k>0;k--)               
     
338.                         {
     
339.                                 for(x=0;x<kuan;x++)
     
340.                                 p->a[x][k]=p->a[x][k-1];        
     
341.                         }
     
342.                         y=y+1;                           //过后重新运行当前行，因为当前行已经改变
     
343.                        
     
344.                 }
     
345.         }
     
346. 
     
347.        
     
348. }
     
349. 
     
350. void main()
     
351. {   
     
352.         int e=0;
     
353.         int n;
     
354.         int time=0;
     
355.         n=rand()%5;
     
356.         n=rand()%5;
     
357.         space *p;
     
358.         p=creatspace();
     
359.     h *head;                                                                //初始化开始
     
360.         initgraph(kuan*10,gao*10);                                //建立图像
     
361.         head=creat(n);                                                        //  创建新的方块
     
362.         while(1)       
     
363.         {        xian(head);
     
364.                 out(p);                    //显示当前存储空间
     
365.                 Sleep(100);
     
366.                 xiao(head);
     
367.                 time++;
     
368.                   if(time==8)
     
369.           {
     
370.            down(head);
     
371.            time=0;
     
372.           }
     
373.                 if(!kbhit())
     
374.                 {
     
375.                
     
376.                 }
     
377.                 else
     
378.                 {
     
379.                         switch(getch())                                                                         //可以在这里直接增加判定，当向左或右或旋转时如果碰边则无效或返回前一个值
     
380.                         {        case 'w':xuan(n,p,head); break;               //可以加个计时器，让旋转等操作与向下平行
     
381.                                 case 'a':left(p,head);break;
     
382.                                 case 'd':right(p,head);break;
     
383.                                 case 's':down(head);break;
     
384.                                 default :break;       
     
385.                         }
     
386.                 }
     
387.    
     
388.        
     
389.                 e=judge(p,head);
     
390.                 if(e==1)
     
391.                 {
     
392.             n=rand()%5;
     
393.                         head=creat(n);
     
394.                         e=0;
     
395.                 }
     
396.                 outxiao(p);                 //消除上一次的存储空间
     
397.                 man(p);                    //满层判定
     
398. 
     
399.        
     
400.             
     
401.         }                                                        //while结束
     
402. 
     
403.     closegraph();
     
404. 
     
405. }

复制代码

735899422

楼主 我看了你的问题我就写了个俄罗斯方块

735899422

首先说下我的思路， 定义一个数组 初始化为0； 方块为1；落下后为2；

漠水

735899422 发表于 2014-12-23 13:45
首先说下我的思路， 定义一个数组 初始化为0； 方块为1；落下后为2；

旋转的问题我已经解决了，还是有点其他的小毛病，这帖子感觉过去好久了，不过还是要谢谢你的解答。。。

735899422

什么小毛病、

漠水

还是有点不懂，能不能把代码发一下，看看，谢谢哈

漠水

735899422 发表于 2014-12-24 09:00
什么小毛病、

还是有点不懂，能不能把代码发一下，看看，谢谢哈

735899422

哪里不懂？

735899422

我的代码只写了一半就不想写了 麻烦 你哪里不懂？

735899422

漠水 发表于 2014-12-24 11:29
还是有点不懂，能不能把代码发一下，看看，谢谢哈

旋转越界不懂吗？

漠水

735899422 发表于 2014-12-24 11:32
我的代码只写了一半就不想写了 麻烦 你哪里不懂？

就是一个反应的机制问题，是下降的时间的控制与按键操作的配合，主要就是一个时间差问题，比如我这个程序如果一直向右的话也会右下角而非右边。不过我已经不纠结这个了，还是非常感谢。

漠水

735899422 发表于 2014-12-24 11:36
旋转越界不懂吗？

恩，我主要是看不出来程序中的旋转越界的操作错在了哪一个步骤上，哪一行，应该说我不怎么会试调，比较不是纯业余的。
具体点说就是：不知道在旋转的时候，判定条件按道理来说应该可以啊，怎么会越界出去呢？还是说存储空间的判定条件出错了？

735899422

你用的是kbhit() 吗？

735899422

漠水 发表于 2014-12-24 11:39
就是一个反应的机制问题，是下降的时间的控制与按键操作的配合，主要就是一个时间差问题，比如我这个程序 ...

你用的是kbhit() 吗？

漠水

735899422 发表于 2014-12-24 11:44
你用的是kbhit() 吗？

呃，是啊，因为只会学到什么用什么，难道有什么问题吗？

735899422

漠水 发表于 2014-12-24 11:45
呃，是啊，因为只会学到什么用什么，难道有什么问题吗？

没问题 我也是用的这个