绘制子弹崩溃

猪猪虾

（我感觉在出连续剧 ，一天更新一点。。。）
同样的方法，绘制飞机可以，绘制子弹就不行了
我先尝试简单的绘制一个子弹，只不过在绘制子弹的时候，子弹的位置是要用到飞机类，也就是要用到飞机的位置，所以在子弹类里面调用了飞机的位置，绘制飞机的位置在 GameMain。cpp的upwindow函数里面

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. 
   
6. using namespace std;
   
7. class GameMain;
   
8. class MyPlane;
   
9. 
   
10. class Bullet
    
11. {
    
12. public:
    
13.         Bullet(GameMain* gm, MyPlane* mp);  //  Bullet  类的构造函数中使用了 GameMain 类的指针  GM 。但是，你没有初始化这个指针
    
14.         static IMAGE getImage_Bullet();
    
15.         void Move();
    
16. 
    
17.         int Bullte_current_posiX;
    
18.         int Bullte_current_posiY;
    
19.         int width;
    
20.         int height;
    
21.         int Bullet_pace;
    
22.         bool BT_IsAlive;
    
23. private:
    
24.         static IMAGE imgBullet;  //static 成员变量属于类，不属于某个具体的对象，即使创建多个对象，也只为 static 成员变量分配一份内存，所有对象使用的都是这份内存中的数据。
    
25.         GameMain* GM;
    
26.         MyPlane* MP;
    
27. };

复制代码

1. #pragma once
   
2. #include<graphics.h>
   
3. #include<cstring>
   
4. #include<vector>
   
5. 
   
6. #include "Bullet.h"
   
7. #include "GameMain.h"
   
8. #include "MyPlane.h"
   
9. 
   
10. //静态成员，需要在类外进行声明
    
11. IMAGE Bullet::imgBullet;  // 这一行为 imgMyplane 分配内存空间
    
12. 
    
13. Bullet::Bullet(GameMain* gm,MyPlane* mp):GM(gm),MP(mp)
    
14. {
    
15.         width = 5;
    
16.         height = 10;
    
17.         Bullet_pace = 20;
    
18.         BT_IsAlive = true;
    
19. 
    
20.         loadimage(&imgBullet, "E:/2022上/Leecode_April/plane/image/bullet1.png");
    
21. 
    
22.         //初始化飞机的位置在图像的正下方的中心
    
23.         Bullte_current_posiX = MP->My_current_posiX ;
    
24.         Bullte_current_posiY = MP->My_current_posiY - MP->height;
    
25. }
    
26. 
    
27. 
    
28. IMAGE Bullet::getImage_Bullet()
    
29. {
    
30.         return imgBullet;
    
31. }
    
32. 
    
33. void Bullet::Move()
    
34. {
    
35.         Bullte_current_posiY -= Bullet_pace;
    
36.         if (Bullte_current_posiY < 0) { BT_IsAlive = false; }
    
37. }
    
38. 
    
39. 
    

复制代码

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. 
   
10. class MyPlane
    
11. {
    
12. public:
    
13.         MyPlane(GameMain* gm);  //  MyPlane  类的构造函数中使用了 GameMain 类的指针  GM 。但是，你没有初始化这个指针
    
14.         //static IMAGE getImages();    //私有成员可以在public里面，通过函数来间接访问和修改
    
15.         void Move(int dx, int dy);
    
16.         static IMAGE getImage_Myplane();
    
17. 
    
18.         int My_current_posiX;
    
19.         int My_current_posiY;
    
20.         int width;
    
21.         int height;
    
22.         int pace;   //每次按键飞机移动的距离
    
23. private:
    
24.         static IMAGE imgMyplane;
    
25.         GameMain *GM;
    
26. };
    

复制代码

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

复制代码

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

复制代码

sfqxx

在子弹类里面调用了飞机的位置，可能是因为未正确初始化 MyPlane 对象，导致子弹无法获取到正确的飞机位置。建议将 MyPlane 对象的初始化代码移动到 GameMain 类的构造函数中，并在 Bullet 类中传入 GameMain 对象和 MyPlane 对象的引用，以便子弹类能够正确获取飞机位置并进行绘制。同时，也需要在 GameMain::updateWindow() 中根据子弹对象的当前位置来更新子弹的绘制位置。以下是示例代码：

1. 
   
2. // GameMain.h
   
3. 
   
4. class GameMain
   
5. {
   
6. public:
   
7.     GameMain();
   
8.     ~GameMain();
   
9. 
   
10.     // ...
    
11. 
    
12. private:
    
13.     MyPlane MP;
    
14.     Bullet BT;
    
15. 
    
16.     // ...
    
17. };
    
18. 
    
19. // Bullet.h
    
20. 
    
21. #include "GameMain.h"
    
22. #include "MyPlane.h"
    
23. 
    
24. class Bullet {
    
25. public:
    
26.     Bullet(GameMain& game, MyPlane& plane);
    
27.     ~Bullet();
    
28. 
    
29.     void update();
    
30.     IMAGE getImage_Bullet();
    
31. 
    
32. private:
    
33.     GameMain& m_game; // 引用 GameMain 对象
    
34.     MyPlane& m_plane; // 引用 MyPlane 对象
    
35. 
    
36.     int Bullte_width=8;
    
37.     int Bullte_height=24;
    
38.     int Bullte_current_posiX;
    
39.     int Bullte_current_posiY;
    
40.     IMAGE img_DM_bullet;
    
41. };
    
42. 
    
43. // Bullet.cpp
    
44. 
    
45. Bullet::Bullet(GameMain& game, MyPlane& plane)
    
46.     : m_game(game), m_plane(plane)
    
47. {
    
48.     Bullte_current_posiX = m_plane.My_current_posiX + m_plane.width / 2 - Bullte_width / 2;
    
49.     Bullte_current_posiY = m_plane.My_current_posiY - Bullte_height;
    
50.     loadimage(&img_DM_bullet, "E:/cpp_proj/plane/image/bullet.png");
    
51. }
    
52. 
    
53. void Bullet::update()
    
54. {
    
55.     Bullte_current_posiY -= 10; // 子弹向上移动
    
56.     if (Bullte_current_posiY < 0) // 当子弹飞出屏幕时，重置子弹位置
    
57.     {
    
58.         Bullte_current_posiX = m_plane.My_current_posiX + m_plane.width / 2 - Bullte_width

复制代码

猪猪虾

sfqxx 发表于 2023-5-4 19:03
在子弹类里面调用了飞机的位置，可能是因为未正确初始化 MyPlane 对象，导致子弹无法获取到正确的飞机位置 ...

在class GameMain.h里面定义   这种MyPlane MP而不是这种 MyPlane *MP;我这边会显示使用没有定义的class，我一开始就想不用指针的形式，后来没办法才用的指针

sfqxx

猪猪虾 发表于 2023-5-4 19:45
在class GameMain.h里面定义   这种MyPlane MP而不是这种 MyPlane *MP;我这边会显示使用没有定义的class ...

然后呢

isdkz

看起来你的代码想要实现一个飞机发射子弹的游戏。你可以成功地绘制飞机，但在绘制子弹时出现了问题。这是因为你在子弹类中使用了飞机的位置来初始化子弹的位置。在你的GameMain类中，你已经创建了一个MyPlane实例（MP）和一个Bullet实例（BT）。

要解决这个问题：

首先，在GameMain类中，添加一个表示子弹列表的向量成员：

1. vector<Bullet*> bullets;
   

复制代码

接着，在 keyEvent 函数中，当按下空格键时创建新的Bullet实例并添加到子弹列表中：

1. if (_kbhit()) {
   
2.     ch = _getch();
   
3.     // 添加以下代码来处理空格键按下
   
4.     if (ch == 32) {
   
5.         Bullet* newBullet = new Bullet(this, MP);
   
6.         bullets.push_back(newBullet);
   
7.     } else if (ch == 224) {
   
8.     ...
   
9. }
   

复制代码

为了避免内存泄漏，记得在GameMain的析构函数删除bullets向量中所有创建的Bullet实例：

1. GameMain::~GameMain() {
   
2.     delete MP;
   
3. 
   
4.     for (Bullet* bullet : bullets){
   
5.         delete bullet;
   
6.     }
   
7. }
   

复制代码

最后，在 updateWindow 函数中，遍历bullets向量中的每一个bullet，并更新它们的位置，然后绘制它们：

1. for (Bullet* bullet : bullets) {
   
2.     bullet->Move();
   
3.     IMAGE TEMP_BT;
   
4.     TEMP_BT = bullet->getImage_Bullet();
   
5.     putimage(bullet->Bullte_current_posiX, bullet->Bullte_current_posiY, &TEMP_BT);
   
6. }
   

复制代码

现在，当你按下空格键时，子弹应该会从飞机的位置创建并向上移动。请注意，上述更改可能无法解决所有问题，你可能需要调整一些其他部分以确保游戏按预期工作。

猪猪虾

isdkz 发表于 2023-5-4 20:19
看起来你的代码想要实现一个飞机发射子弹的游戏。你可以成功地绘制飞机，但在绘制子弹时出现了问题。这是因 ...

这是因为你在子弹类中使用了飞机的位置来初始化子弹的位置。这个理论上也没啥毛病吧，问题的本质是啥呢，我断点进入子弹的构造函数，子弹的位置是被赋予了的，一直执行到绘图的时候才崩溃

您提供的修改是绘图方式的不同，我那个可能就一次只绘制了一颗子弹