[已解决]为什么按键控制飞机移动无效，只有在程序点击运行的时候，我按下按键，可以运动一下

猪猪虾

动这一下之后，后面按键就无效了
我测试了，第一下那个dx,dy是传进去了的，应该是后面的按键就没传进去

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. //#include<MyPlane.h> 如果这里这么用，会发现 当前.h文件和MyPlane.h文件的彼此头文件相互包含，会报错
   
6. class MyPlane;  //告诉编译器，需要这个类，其他功能结构都没变
   
7. using namespace std;
   
8. 
   
9. class GameMain
   
10. {
    
11. public:
    
12.         //构造函数  用于初始化参数，游戏界面设置
    
13. 
    
14.         GameMain();
    
15. 
    
16.         //注意，你需要在  GameMain  类的析构函数中删除  MyPlane  
    
17.    //类的实例*以避免内存泄漏。在  GameMain  类中添加一个析构函数，并在其中删除  MP ：GameMain.h文件
    
18.         ~GameMain();  // 添加析构函数
    
19.         //游戏界面初始化
    
20.         void init();
    
21.         void paly(); // 开始游戏
    
22.         int* getBgSize();
    
23. 
    
24.         int rows;
    
25.         int cols;
    
26. 
    
27. private:
    
28.         void keyEvent();  //按键控制
    
29.         void updateWindow();  //渲染界面
    
30. 
    
31. private:
    
32.         bool update;
    
33. 
    
34.         // 添加这一行,这样其他地方调用这个类的时候，就不用每次都申明，不同地方申明，还是不同的对象，无法
    
35.         //实现同时操作一辆飞机
    
36.         MyPlane *MP;
    
37. 
    
38.         //背景图像参数
    
39.         IMAGE imgBg;  //背景图片
    
40. 
    
41.         //创建一个动态数组bullets，里面的元素都是一个个Bullet对象
    
42.         //std::vector<Bullet> bullets;  // 添加子弹容器
    
43. };
    

复制代码

1. #include "GameMain.h"
   
2. #include "MyPlane.h"
   
3. #include "Bullet.h"
   
4. #include<stdlib.h>
   
5. #include <time.h>
   
6. #include<graphics.h>
   
7. #include <conio.h>
   
8. #include"iostream"
   
9. #include"string"
   
10. #include "fstream"
    
11. //音效
    
12. #include<mmsystem.h>
    
13. #pragma comment(lib,"winmm.lib")
    
14. #pragma comment(lib,"WINMM.LIB")
    
15. 
    
16. using namespace std;
    
17. 
    
18. GameMain::GameMain()
    
19. {
    
20.         rows = 438;
    
21.         cols = 675;
    
22.         MP = new MyPlane(this);  // 在创建 MyPlane 实例时传递 GameMain 类的指针
    
23.         // 为 MyPlane 类对象的指针 MP 分配内存空间
    
24.         //MP = new MyPlane();
    
25.         //将游戏界面的宽度指定成背景图片的显示宽度
    
26. 
    
27. }
    
28. 
    
29. //析构函数主要作用就是释放资源, 避免内存泄漏
    
30. GameMain::~GameMain()
    
31. {
    
32.         delete MP;  // 删除 MyPlane 实例
    
33. }
    
34. 
    
35. void GameMain::init()
    
36. {
    
37.         //播放背景音乐
    
38.         mciSendString("play E:/res/bg.mp3 repeat", 0, 0, 0);
    
39. 
    
40.         //创建游戏窗口
    
41.         *initgraph(rows, cols);
    
42. 
    
43.         //加载背景图片
    
44.         loadimage(&imgBg, "E:/Leecode_April/plane/image/background.png");
    
45. 
    
46.         update = true;
    
47. }
    
48. 
    
49. void GameMain::paly()
    
50. {
    
51.         init();
    
52. 
    
53.         update = true;
    
54.         while (1)
    
55.         {
    
56.                 BeginBatchDraw();
    
57. 
    
58.                 //接收用户的输入
    
59.                 keyEvent();
    
60.                 if (update == true) {
    
61.                         //更新游戏画面
    
62.                         updateWindow();
    
63.                 }
    
64.                
    
65.                 system("pause");
    
66.                 EndBatchDraw();
    
67.         }
    
68. }
    
69. 
    
70. int* GameMain::getBgSize()
    
71. {
    
72.         int num[] = { rows ,cols };
    
73.         int* ptr = new int[2];
    
74.         for (int i = 0; i < 2; i++) {
    
75.                 ptr[i] = num[i];
    
76.         }
    
77.         return ptr;
    
78. }
    
79. 
    
80. 
    
81. void GameMain::keyEvent()
    
82. {
    
83.         unsigned char ch;
    
84.         int dx = 0;
    
85.         int dy = 0;
    
86. 
    
87.         //判断当前有没有按键输入,如果他没有按键输入，程序正常执行
    
88.         if (_kbhit()) {
    
89.                 ch = _getch();
    
90. 
    
91.                 //按下字母，返回的就是字母，按下的是方向键
    
92.                 //上，先后返回: 224 72  下：224 80   左:75 224,75  右：224 77
    
93.                 if (ch == 224) {
    
94.                         ch = _getch();
    
95.                         switch (ch) {
    
96.                         case 72:
    
97.                                 dy = -MP->pace;
    
98.                                 break;
    
99.                         case 80:
    
100.                                 dy = MP->pace;
     
101.                                 break;
     
102.                         case 75:
     
103.                                 dx = -MP->pace;
     
104.                                 break;
     
105.                         case 77:
     
106.                                 dx = MP->pace;
     
107.                                 break;
     
108.                         default:
     
109.                                 break;
     
110.                         }
     
111.                 }
     
112.         }
     
113.         if (dx != 0 || dy != 0)  //左右移动
     
114.         {
     
115. //                MyPlane MP;
     
116.                 MP->Move(dx,dy);
     
117.         //        MP->Move(-20,- 20);
     
118.                 update = true;
     
119.         }
     
120. }
     
121. 
     
122. void GameMain::updateWindow()
     
123. {
     
124.         putimage(0, 0, &imgBg);
     
125.         BeginBatchDraw();
     
126. 
     
127.         //绘制我方飞机
     
128.         //MyPlane MP;
     
129.         IMAGE TEMP_my;
     
130.         TEMP_my = MP->getImage_Myplane();
     
131.         putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_my);
     
132. 
     
133.         //绘制子弹
     
134.         //Bullet BT;
     
135.         //IMAGE TEMP_BT;
     
136.         //TEMP_BT = BT.getImage_Bullet();
     
137.         //putimage(MP->My_current_posiX, MP->My_current_posiY, &TEMP_BT);
     
138.         //for (Bullet& bullet : bullets) {
     
139.         //        bullet.update();  // 更新子弹位置
     
140.         //        IMAGE TEMP_BT;
     
141.         //        TEMP_BT = bullet.getImage_Bullet();
     
142.         //        putimage(bullet.getPosX(), bullet.getPosY(), &TEMP_BT);
     
143.         //}
     
144. 
     
145.         EndBatchDraw();
     
146. }
     
147. 
     

复制代码

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. //#include "GameMain.h"
   
6. using namespace std;
   
7. class GameMain;
   
8. 
   
9. class MyPlane
   
10. {
    
11. public:
    
12.         MyPlane(GameMain* gm);  //  MyPlane  类的构造函数中使用了 GameMain 类的指针  GM 。但是，你没有初始化这个指针
    
13.         //static IMAGE getImages();    //私有成员可以在public里面，通过函数来间接访问和修改
    
14.         void Move(int dx, int dy);
    
15.         static IMAGE getImage_Myplane();
    
16. 
    
17.         int My_current_posiX;
    
18.         int My_current_posiY;
    
19.         int width;
    
20.         int height;
    
21.         int pace;   //每次按键飞机移动的距离
    
22. private:
    
23.         static IMAGE imgMyplane;
    
24.         GameMain *GM;
    
25. };
    

复制代码

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. #include "MyPlane.h"
   
6. #include "GameMain.h"
   
7. 
   
8. using namespace std;
   
9. //静态成员，需要在类外进行声明
   
10. IMAGE MyPlane::imgMyplane;  // 这一行为 imgMyplane 分配内存空间
    
11. 
    
12. //`MyPlane` 类在头文件 `MyPlane.h` 中声明，而 `imgMyplane` 的定义位于与类实现相关联的源文件
    
13. //`MyPlane.cpp` 中。这样，您就解决了 `LNK2001` 错误。
    
14. //如果您将所有代码放在同一个文件中，那么只需在类定义之后添加 `IMAGE MyPlane::imgMyplane; ` 这一行即可。
    
15. //IMAGE MyPlane::imgMyplane;  // 这一行为 imgMyplane 分配内存空间
    
16. 
    
17. 
    
18. MyPlane::MyPlane(GameMain* gm):GM(gm)
    
19. {
    
20.         width = 100;
    
21.         height = 125;
    
22.         pace = 20;
    
23.         loadimage(&imgMyplane, "E:/Leecode_April/plane/image/me1.png");
    
24. 
    
25.         //初始化飞机的位置在图像的正下方的中心
    
26.        
    
27.         My_current_posiX = GM->rows / 2 - width / 2;
    
28.         My_current_posiY = GM->cols - height;
    
29. }
    
30. 
    
31. IMAGE MyPlane::getImage_Myplane()
    
32. {
    
33.         return imgMyplane;
    
34. }
    
35. 
    
36. void MyPlane::Move(int dx, int dy)
    
37. {
    
38.        
    
39.         My_current_posiX += dx;
    
40.         My_current_posiY += dy;
    
41. 
    
42.         //判断是否超出了边界,还要考虑飞机本身的宽度
    
43.         if (My_current_posiX > (GM->rows - width / 2) || My_current_posiX < width / 2)
    
44.         {
    
45.                 My_current_posiX -= dx;
    
46.         }
    
47. 
    
48.         if (My_current_posiX > (GM->cols - height / 2) || My_current_posiX < height / 2)
    
49.         {
    
50.                 My_current_posiY -= dy;
    
51.         }
    
52. 
    
53. }
    

复制代码

最佳答案

月排行榜 / 总排行榜

isdkz

2023-5-3 22:45:18

猪猪虾 发表于 2023-5-3 22:13
删了，还是不行

在 GameMain::paly() 函数的 while (1) 循环中，删除 BeginBatchDraw(); 和 EndBatchDraw(); 函数调用。这些函数实际上是用于双缓冲技术，用于防止屏幕闪烁，但在这种情况下，它们可能会干扰按键事件的处理。将 GameMain::paly() 函数修改为：

1. void GameMain::paly()
   
2. {
   
3.     init();
   
4. 
   
5.     update = true;
   
6.     while (1)
   
7.     {
   
8.         //接收用户的输入
   
9.         keyEvent();
   
10.         if (update == true) {
    
11.             //更新游戏画面
    
12.             updateWindow();
    
13.         }
    
14.     }
    
15. }
    

复制代码

跳转到最佳答案楼层

isdkz

首先，从你的代码中，我发现了一个问题。在  GameMain::paly()  函数中，你在游戏主循环的每一次迭代后都有一个  system("pause");  调用。这会导致游戏在每一帧之后都暂停并等待用户按下回车键。这可能是你遇到的按键无效问题的原因之一。要解决此问题，请删除  system("pause");  这一行。

另外，在  GameMain::keyEvent()  函数中，你需要在  _kbhit()  调用之前先调用  _flushall() ，以确保在  _kbhit()  调用之前清除任何缓冲的输入。这是一个解决方案：

1. void GameMain::keyEvent()
   
2. {
   
3.     _flushall();  // 添加此行以清除缓冲的输入
   
4.     unsigned char ch;
   
5.     int dx = 0;
   
6.     int dy = 0;
   
7. 
   
8.     //判断当前有没有按键输入,如果他没有按键输入，程序正常执行
   
9.     if (_kbhit()) {
   
10.         ch = _getch();
    
11. 
    
12.         //按下字母，返回的就是字母，按下的是方向键
    
13.         //上，先后返回: 224 72  下：224 80   左:75 224,75  右：224 77
    
14.         if (ch == 224) {
    
15.             ch = _getch();
    
16.             switch (ch) {
    
17.             case 72:
    
18.                 dy = -MP->pace;
    
19.                 break;
    
20.             case 80:
    
21.                 dy = MP->pace;
    
22.                 break;
    
23.             case 75:
    
24.                 dx = -MP->pace;
    
25.                 break;
    
26.             case 77:
    
27.                 dx = MP->pace;
    
28.                 break;
    
29.             default:
    
30.                 break;
    
31.             }
    
32.         }
    
33.     }
    
34.     if (dx != 0 || dy != 0)  //左右移动
    
35.     {
    
36.         MP->Move(dx,dy);
    
37.         update = true;
    
38.     }
    
39. }
    

复制代码

在做了这些更改之后，按键控制应该可以正常工作。希望这可以解决你的问题！

猪猪虾

isdkz 发表于 2023-5-3 21:39
首先，从你的代码中，我发现了一个问题。在  GameMain::paly()  函数中，你在游戏主循环的每一次迭代后都有 ...

还是动不了诶

猪猪虾

isdkz 发表于 2023-5-3 21:39
首先，从你的代码中，我发现了一个问题。在  GameMain::paly()  函数中，你在游戏主循环的每一次迭代后都有 ...

https://blog.csdn.net/weixin_43528481/article/details/130252992?spm=1001.2014.3001.5502
我是仿照这个俄罗斯方块写的，虽然不是一个游戏，但是思路差不多

isdkz

猪猪虾 发表于 2023-5-3 21:42
还是动不了诶

system("pause"); 删了吗？

猪猪虾

isdkz 发表于 2023-5-3 22:05
system("pause"); 删了吗？

删了，还是不行

isdkz

猪猪虾 发表于 2023-5-3 22:13
删了，还是不行

在 GameMain::paly() 函数的 while (1) 循环中，删除 BeginBatchDraw(); 和 EndBatchDraw(); 函数调用。这些函数实际上是用于双缓冲技术，用于防止屏幕闪烁，但在这种情况下，它们可能会干扰按键事件的处理。将 GameMain::paly() 函数修改为：

1. void GameMain::paly()
   
2. {
   
3.     init();
   
4. 
   
5.     update = true;
   
6.     while (1)
   
7.     {
   
8.         //接收用户的输入
   
9.         keyEvent();
   
10.         if (update == true) {
    
11.             //更新游戏画面
    
12.             updateWindow();
    
13.         }
    
14.     }
    
15. }
    

复制代码

猪猪虾

isdkz 发表于 2023-5-3 22:45
在 GameMain::paly() 函数的 while (1) 循环中，删除 BeginBatchDraw(); 和 EndBatchDraw(); 函数调用。 ...

删掉确实可以了，但是频闪