深入浅出用C语言编写落体反弹物理模拟程序的实用教程

威震华夏关云长

1. 物理模拟基础

物理模拟是通过计算机程序来模拟现实世界中的物理现象。在本文中，我们将专注于模拟一个物体在重力作用下下落并反弹的简单物理系统。这种模拟不仅有助于理解基本的物理原理，也是学习编程和计算机图形学的绝佳入门项目。

1.1 落体反弹的物理原理

在现实世界中，当一个物体从高处落下时，它受到重力的作用而加速下降。当物体撞击地面时，它会根据材料的弹性发生反弹。每次反弹后，物体达到的高度会逐渐降低，直到最终停止弹跳。

这个过程中涉及几个关键的物理概念：

• 重力加速度：在地球表面，物体自由下落的加速度约为9.8 m/s²，通常用g表示。
• 速度：物体的速度随时间变化，v = v₀ + gt，其中v₀是初始速度。
• 位置：物体的位置随时间变化，y = y₀ + v₀t + ½gt²，其中y₀是初始位置。
• 能量损失：每次反弹时，由于空气阻力和碰撞时的能量转化，物体会有部分能量损失，通常用恢复系数（coefficient of restitution）表示。

1.2 模拟的基本思路

在计算机程序中模拟这个物理过程，我们需要：

1. 定义物体的初始状态（位置、速度）
2. 在每个时间步长更新物体的速度和位置
3. 检测物体是否与地面碰撞
4. 如果发生碰撞，计算反弹后的速度
5. 重复上述过程，直到满足结束条件

2. 程序设计

2.1 开发环境准备

在开始编写代码之前，我们需要准备一个适合C语言开发的環境。对于本教程，我们假设您已经安装了：

• C编译器（如GCC）
• 一个文本编辑器或IDE（如Visual Studio Code、Dev-C++等）
• 如果需要图形显示，还需要安装图形库（如SDL、OpenGL或简单的控制台图形库）

2.2 程序结构设计

我们的程序将包含以下几个主要部分：

1. 头文件包含：包含必要的库文件
2. 常量定义：定义物理常量和模拟参数
3. 全局变量：存储物体的状态信息
4. 初始化函数：设置初始条件
5. 物理更新函数：计算物体在每个时间步长的状态
6. 碰撞检测函数：检测并处理物体与地面的碰撞
7. 显示函数：在屏幕上绘制物体的位置
8. 主循环：控制模拟的进行

3. 代码实现

3.1 基本框架

首先，我们创建程序的基本框架：

2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <math.h>
5. #include <time.h>
7. // 物理常量
8. #define GRAVITY 9.8        // 重力加速度 (m/s²)
9. #define TIME_STEP 0.01     // 时间步长 (s)
10. #define COEFF_RESTITUTION 0.8  // 恢复系数
12. // 模拟参数
13. #define GROUND_LEVEL 0.0   // 地面位置 (m)
14. #define INITIAL_HEIGHT 10.0 // 初始高度 (m)
15. #define INITIAL_VELOCITY 0.0 // 初始速度 (m/s)
17. // 全局变量
18. double position = INITIAL_HEIGHT;  // 当前位置
19. double velocity = INITIAL_VELOCITY; // 当前速度
20. double time = 0.0;                 // 模拟时间
21. int bounce_count = 0;              // 反弹次数
23. // 函数声明
24. void initialize_simulation();
25. void update_physics();
26. void check_collision();
27. void display_state();
28. void run_simulation();
30. int main() {
31.     run_simulation();
32.     return 0;
33. }

复制代码

3.2 初始化函数

初始化函数用于设置模拟的初始条件：

2. void initialize_simulation() {
3.     position = INITIAL_HEIGHT;
4.     velocity = INITIAL_VELOCITY;
5.     time = 0.0;
6.     bounce_count = 0;
7.    
8.     printf("落体反弹物理模拟程序\n");
9.     printf("初始高度: %.2f m\n", INITIAL_HEIGHT);
10.     printf("初始速度: %.2f m/s\n", INITIAL_VELOCITY);
11.     printf("重力加速度: %.2f m/s²\n", GRAVITY);
12.     printf("恢复系数: %.2f\n", COEFF_RESTITUTION);
13.     printf("--------------------------------\n");
14. }

复制代码

3.3 物理更新函数

物理更新函数负责计算物体在每个时间步长的速度和位置：

2. void update_physics() {
3.     // 更新速度 (v = v0 + g*t)
4.     velocity -= GRAVITY * TIME_STEP;
5.    
6.     // 更新位置 (y = y0 + v*t)
7.     position += velocity * TIME_STEP;
8.    
9.     // 更新时间
10.     time += TIME_STEP;
11. }

复制代码

3.4 碰撞检测函数

碰撞检测函数检查物体是否与地面碰撞，并处理反弹：

2. void check_collision() {
3.     // 检测是否与地面碰撞
4.     if (position <= GROUND_LEVEL && velocity < 0) {
5.         // 确保物体不会穿透地面
6.         position = GROUND_LEVEL;
7.         
8.         // 计算反弹速度 (v' = -e*v)
9.         velocity = -velocity * COEFF_RESTITUTION;
10.         
11.         // 增加反弹计数
12.         bounce_count++;
13.         
14.         printf("时间: %.2f s, 第 %d 次反弹, 反弹速度: %.2f m/s\n",
15.                time, bounce_count, fabs(velocity));
16.     }
17. }

复制代码

3.5 显示函数

显示函数用于输出当前物体状态：

2. void display_state() {
3.     // 每隔一定时间输出一次状态
4.     static int counter = 0;
5.     counter++;
6.    
7.     if (counter >= 10) {  // 每10个时间步长输出一次
8.         printf("时间: %.2f s, 位置: %.2f m, 速度: %.2f m/s\n",
9.                time, position, velocity);
10.         counter = 0;
11.     }
12. }

复制代码

3.6 主循环函数

主循环函数控制整个模拟的进行：

2. void run_simulation() {
3.     // 初始化模拟
4.     initialize_simulation();
5.    
6.     // 模拟循环
7.     while (time < 10.0) {  // 模拟10秒
8.         // 更新物理状态
9.         update_physics();
10.         
11.         // 检测碰撞
12.         check_collision();
13.         
14.         // 显示当前状态
15.         display_state();
16.         
17.         // 检查是否停止弹跳（速度非常小且在地面上）
18.         if (fabs(velocity) < 0.1 && position <= GROUND_LEVEL + 0.01) {
19.             printf("物体在 %.2f 秒后停止弹跳，共反弹 %d 次\n",
20.                    time, bounce_count);
21.             break;
22.         }
23.     }
24.    
25.     printf("模拟结束\n");
26. }

复制代码

4. 完整代码示例

将上述所有部分组合起来，我们得到完整的落体反弹物理模拟程序：

2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <math.h>
5. #include <time.h>
7. // 物理常量
8. #define GRAVITY 9.8        // 重力加速度 (m/s²)
9. #define TIME_STEP 0.01     // 时间步长 (s)
10. #define COEFF_RESTITUTION 0.8  // 恢复系数
12. // 模拟参数
13. #define GROUND_LEVEL 0.0   // 地面位置 (m)
14. #define INITIAL_HEIGHT 10.0 // 初始高度 (m)
15. #define INITIAL_VELOCITY 0.0 // 初始速度 (m/s)
17. // 全局变量
18. double position = INITIAL_HEIGHT;  // 当前位置
19. double velocity = INITIAL_VELOCITY; // 当前速度
20. double time = 0.0;                 // 模拟时间
21. int bounce_count = 0;              // 反弹次数
23. // 函数声明
24. void initialize_simulation();
25. void update_physics();
26. void check_collision();
27. void display_state();
28. void run_simulation();
30. int main() {
31.     run_simulation();
32.     return 0;
33. }
35. void initialize_simulation() {
36.     position = INITIAL_HEIGHT;
37.     velocity = INITIAL_VELOCITY;
38.     time = 0.0;
39.     bounce_count = 0;
40.    
41.     printf("落体反弹物理模拟程序\n");
42.     printf("初始高度: %.2f m\n", INITIAL_HEIGHT);
43.     printf("初始速度: %.2f m/s\n", INITIAL_VELOCITY);
44.     printf("重力加速度: %.2f m/s²\n", GRAVITY);
45.     printf("恢复系数: %.2f\n", COEFF_RESTITUTION);
46.     printf("--------------------------------\n");
47. }
49. void update_physics() {
50.     // 更新速度 (v = v0 + g*t)
51.     velocity -= GRAVITY * TIME_STEP;
52.    
53.     // 更新位置 (y = y0 + v*t)
54.     position += velocity * TIME_STEP;
55.    
56.     // 更新时间
57.     time += TIME_STEP;
58. }
60. void check_collision() {
61.     // 检测是否与地面碰撞
62.     if (position <= GROUND_LEVEL && velocity < 0) {
63.         // 确保物体不会穿透地面
64.         position = GROUND_LEVEL;
65.         
66.         // 计算反弹速度 (v' = -e*v)
67.         velocity = -velocity * COEFF_RESTITUTION;
68.         
69.         // 增加反弹计数
70.         bounce_count++;
71.         
72.         printf("时间: %.2f s, 第 %d 次反弹, 反弹速度: %.2f m/s\n",
73.                time, bounce_count, fabs(velocity));
74.     }
75. }
77. void display_state() {
78.     // 每隔一定时间输出一次状态
79.     static int counter = 0;
80.     counter++;
81.    
82.     if (counter >= 10) {  // 每10个时间步长输出一次
83.         printf("时间: %.2f s, 位置: %.2f m, 速度: %.2f m/s\n",
84.                time, position, velocity);
85.         counter = 0;
86.     }
87. }
89. void run_simulation() {
90.     // 初始化模拟
91.     initialize_simulation();
92.    
93.     // 模拟循环
94.     while (time < 10.0) {  // 模拟10秒
95.         // 更新物理状态
96.         update_physics();
97.         
98.         // 检测碰撞
99.         check_collision();
100.         
101.         // 显示当前状态
102.         display_state();
103.         
104.         // 检查是否停止弹跳（速度非常小且在地面上）
105.         if (fabs(velocity) < 0.1 && position <= GROUND_LEVEL + 0.01) {
106.             printf("物体在 %.2f 秒后停止弹跳，共反弹 %d 次\n",
107.                    time, bounce_count);
108.             break;
109.         }
110.     }
111.    
112.     printf("模拟结束\n");
113. }

复制代码

5. 代码解释和改进方向

5.1 代码解释

这个程序模拟了一个物体在重力作用下下落并反弹的过程。下面是对代码主要部分的解释：

1. 常量定义：我们定义了物理常量（如重力加速度）和模拟参数（如初始高度），这些值可以根据需要进行调整。
2. 全局变量：我们使用全局变量来跟踪物体的状态（位置、速度）和模拟信息（时间、反弹次数）。
3. 物理更新：update_physics()函数根据物理定律更新物体的速度和位置。我们使用简单的欧拉方法进行数值积分。
4. 碰撞检测：check_collision()函数检测物体是否与地面碰撞，并在碰撞时计算反弹速度。反弹速度由恢复系数决定，该系数表示碰撞后保留的动能比例。
5. 模拟循环：run_simulation()函数控制整个模拟过程，包括初始化、循环更新和结束条件检查。

常量定义：我们定义了物理常量（如重力加速度）和模拟参数（如初始高度），这些值可以根据需要进行调整。

全局变量：我们使用全局变量来跟踪物体的状态（位置、速度）和模拟信息（时间、反弹次数）。

物理更新：update_physics()函数根据物理定律更新物体的速度和位置。我们使用简单的欧拉方法进行数值积分。

碰撞检测：check_collision()函数检测物体是否与地面碰撞，并在碰撞时计算反弹速度。反弹速度由恢复系数决定，该系数表示碰撞后保留的动能比例。

模拟循环：run_simulation()函数控制整个模拟过程，包括初始化、循环更新和结束条件检查。

5.2 可能的改进方向

虽然这个基本程序能够模拟落体反弹的过程，但还有许多可以改进的地方：

当前的程序只在控制台输出文本信息。我们可以添加图形显示，使模拟更加直观。例如，使用SDL库创建一个简单的窗口，并在其中绘制物体的运动：

2. // 需要安装SDL库
3. #include <SDL2/SDL.h>
5. #define WINDOW_WIDTH 800
6. #define WINDOW_HEIGHT 600
7. #define SCALE 50  // 像素/米的比例
9. SDL_Window* window = NULL;
10. SDL_Renderer* renderer = NULL;
12. void init_graphics() {
13.     SDL_Init(SDL_INIT_VIDEO);
14.     window = SDL_CreateWindow("落体反弹模拟",
15.                              SDL_WINDOWPOS_UNDEFINED,
16.                              SDL_WINDOWPOS_UNDEFINED,
17.                              WINDOW_WIDTH, WINDOW_HEIGHT,
18.                              SDL_WINDOW_SHOWN);
19.     renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
20. }
22. void draw_scene() {
23.     // 清除屏幕
24.     SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
25.     SDL_RenderClear(renderer);
26.    
27.     // 绘制地面
28.     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
29.     SDL_RenderDrawLine(renderer, 0, WINDOW_HEIGHT - 50, WINDOW_WIDTH, WINDOW_HEIGHT - 50);
30.    
31.     // 计算物体在屏幕上的位置
32.     int screen_x = WINDOW_WIDTH / 2;
33.     int screen_y = WINDOW_HEIGHT - 50 - (int)(position * SCALE);
34.    
35.     // 绘制物体
36.     SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
37.     SDL_Rect ball = {screen_x - 10, screen_y - 10, 20, 20};
38.     SDL_RenderFillRect(renderer, &ball);
39.    
40.     // 更新屏幕
41.     SDL_RenderPresent(renderer);
42. }
44. void close_graphics() {
45.     SDL_DestroyRenderer(renderer);
46.     SDL_DestroyWindow(window);
47.     SDL_Quit();
48. }

复制代码

然后，我们需要修改主循环以包含图形更新：

2. void run_simulation() {
3.     // 初始化模拟
4.     initialize_simulation();
5.    
6.     // 初始化图形
7.     init_graphics();
8.    
9.     // 模拟循环
10.     SDL_Event e;
11.     int quit = 0;
12.    
13.     while (!quit && time < 10.0) {
14.         // 处理事件
15.         while (SDL_PollEvent(&e) != 0) {
16.             if (e.type == SDL_QUIT) {
17.                 quit = 1;
18.             }
19.         }
20.         
21.         // 更新物理状态
22.         update_physics();
23.         
24.         // 检测碰撞
25.         check_collision();
26.         
27.         // 显示当前状态
28.         display_state();
29.         
30.         // 绘制场景
31.         draw_scene();
32.         
33.         // 检查是否停止弹跳
34.         if (fabs(velocity) < 0.1 && position <= GROUND_LEVEL + 0.01) {
35.             printf("物体在 %.2f 秒后停止弹跳，共反弹 %d 次\n",
36.                    time, bounce_count);
37.             break;
38.         }
39.         
40.         // 控制帧率
41.         SDL_Delay(10);
42.     }
43.    
44.     // 关闭图形
45.     close_graphics();
46.    
47.     printf("模拟结束\n");
48. }

复制代码

当前的模拟使用简单的欧拉方法进行数值积分，这可能会导致一些误差。我们可以使用更精确的数值积分方法，如Verlet积分或Runge-Kutta方法。

例如，使用Verlet积分：

2. void update_physics_verlet() {
3.     double acceleration = -GRAVITY;
4.     double new_position = 2 * position - prev_position + acceleration * TIME_STEP * TIME_STEP;
5.    
6.     prev_position = position;
7.     position = new_position;
8.    
9.     // 速度可以通过位置差计算
10.     velocity = (position - prev_position) / TIME_STEP;
11.    
12.     // 更新时间
13.     time += TIME_STEP;
14. }

复制代码

使用这种方法需要添加一个prev_position变量来存储上一时刻的位置。

现实世界中，物体下落时还会受到空气阻力的影响。我们可以添加一个简单的空气阻力模型：

2. #define AIR_RESISTANCE 0.1  // 空气阻力系数
4. void update_physics_with_air_resistance() {
5.     // 计算空气阻力 (F = -b*v)
6.     double air_resistance_force = -AIR_RESISTANCE * velocity;
7.    
8.     // 计算总加速度 (a = g + F/m)
9.     double acceleration = -GRAVITY + air_resistance_force;
10.    
11.     // 更新速度 (v = v0 + a*t)
12.     velocity += acceleration * TIME_STEP;
13.    
14.     // 更新位置 (y = y0 + v*t)
15.     position += velocity * TIME_STEP;
16.    
17.     // 更新时间
18.     time += TIME_STEP;
19. }

复制代码

我们可以扩展程序以模拟多个物体的落体反弹：

2. #define MAX_OBJECTS 10
4. typedef struct {
5.     double position;
6.     double velocity;
7.     double mass;
8.     double radius;
9.     int bounce_count;
10. } PhysicsObject;
12. PhysicsObject objects[MAX_OBJECTS];
13. int object_count = 0;
15. void add_object(double initial_height, double initial_velocity, double mass, double radius) {
16.     if (object_count < MAX_OBJECTS) {
17.         objects[object_count].position = initial_height;
18.         objects[object_count].velocity = initial_velocity;
19.         objects[object_count].mass = mass;
20.         objects[object_count].radius = radius;
21.         objects[object_count].bounce_count = 0;
22.         object_count++;
23.     }
24. }
26. void update_physics_multiple() {
27.     for (int i = 0; i < object_count; i++) {
28.         // 更新速度
29.         objects[i].velocity -= GRAVITY * TIME_STEP;
30.         
31.         // 更新位置
32.         objects[i].position += objects[i].velocity * TIME_STEP;
33.         
34.         // 检测碰撞
35.         if (objects[i].position <= GROUND_LEVEL && objects[i].velocity < 0) {
36.             objects[i].position = GROUND_LEVEL;
37.             objects[i].velocity = -objects[i].velocity * COEFF_RESTITUTION;
38.             objects[i].bounce_count++;
39.         }
40.     }
41.    
42.     // 更新时间
43.     time += TIME_STEP;
44. }

复制代码

如果我们模拟多个物体，还需要考虑它们之间的碰撞：

2. void check_object_collisions() {
3.     for (int i = 0; i < object_count; i++) {
4.         for (int j = i + 1; j < object_count; j++) {
5.             // 计算物体间的距离
6.             double distance = fabs(objects[i].position - objects[j].position);
7.             
8.             // 检测是否碰撞
9.             if (distance < (objects[i].radius + objects[j].radius)) {
10.                 // 简单的弹性碰撞处理
11.                 double temp_velocity = objects[i].velocity;
12.                 objects[i].velocity = objects[j].velocity * COEFF_RESTITUTION;
13.                 objects[j].velocity = temp_velocity * COEFF_RESTITUTION;
14.                
15.                 // 分离物体，避免重叠
16.                 double overlap = (objects[i].radius + objects[j].radius) - distance;
17.                 if (objects[i].position < objects[j].position) {
18.                     objects[i].position -= overlap / 2;
19.                     objects[j].position += overlap / 2;
20.                 } else {
21.                     objects[i].position += overlap / 2;
22.                     objects[j].position -= overlap / 2;
23.                 }
24.             }
25.         }
26.     }
27. }

复制代码

6. 完整的改进版代码示例

下面是一个包含图形显示和空气阻力的完整改进版代码示例：

2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <math.h>
5. #include <time.h>
6. #include <SDL2/SDL.h>
8. // 物理常量
9. #define GRAVITY 9.8           // 重力加速度 (m/s²)
10. #define TIME_STEP 0.01        // 时间步长 (s)
11. #define COEFF_RESTITUTION 0.8 // 恢复系数
12. #define AIR_RESISTANCE 0.05   // 空气阻力系数
14. // 模拟参数
15. #define GROUND_LEVEL 0.0      // 地面位置 (m)
16. #define INITIAL_HEIGHT 10.0   // 初始高度 (m)
17. #define INITIAL_VELOCITY 0.0  // 初始速度 (m/s)
19. // 图形参数
20. #define WINDOW_WIDTH 800
21. #define WINDOW_HEIGHT 600
22. #define SCALE 30  // 像素/米的比例
24. // 全局变量
25. double position = INITIAL_HEIGHT;  // 当前位置
26. double velocity = INITIAL_VELOCITY; // 当前速度
27. double time = 0.0;                 // 模拟时间
28. int bounce_count = 0;              // 反弹次数
30. // SDL变量
31. SDL_Window* window = NULL;
32. SDL_Renderer* renderer = NULL;
34. // 函数声明
35. void initialize_simulation();
36. void update_physics();
37. void check_collision();
38. void display_state();
39. void init_graphics();
40. void draw_scene();
41. void close_graphics();
42. void run_simulation();
44. int main() {
45.     run_simulation();
46.     return 0;
47. }
49. void initialize_simulation() {
50.     position = INITIAL_HEIGHT;
51.     velocity = INITIAL_VELOCITY;
52.     time = 0.0;
53.     bounce_count = 0;
54.    
55.     printf("落体反弹物理模拟程序\n");
56.     printf("初始高度: %.2f m\n", INITIAL_HEIGHT);
57.     printf("初始速度: %.2f m/s\n", INITIAL_VELOCITY);
58.     printf("重力加速度: %.2f m/s²\n", GRAVITY);
59.     printf("恢复系数: %.2f\n", COEFF_RESTITUTION);
60.     printf("空气阻力系数: %.2f\n", AIR_RESISTANCE);
61.     printf("--------------------------------\n");
62. }
64. void update_physics() {
65.     // 计算空气阻力 (F = -b*v)
66.     double air_resistance_force = -AIR_RESISTANCE * velocity;
67.    
68.     // 计算总加速度 (a = g + F/m)
69.     double acceleration = -GRAVITY + air_resistance_force;
70.    
71.     // 更新速度 (v = v0 + a*t)
72.     velocity += acceleration * TIME_STEP;
73.    
74.     // 更新位置 (y = y0 + v*t)
75.     position += velocity * TIME_STEP;
76.    
77.     // 更新时间
78.     time += TIME_STEP;
79. }
81. void check_collision() {
82.     // 检测是否与地面碰撞
83.     if (position <= GROUND_LEVEL && velocity < 0) {
84.         // 确保物体不会穿透地面
85.         position = GROUND_LEVEL;
86.         
87.         // 计算反弹速度 (v' = -e*v)
88.         velocity = -velocity * COEFF_RESTITUTION;
89.         
90.         // 增加反弹计数
91.         bounce_count++;
92.         
93.         printf("时间: %.2f s, 第 %d 次反弹, 反弹速度: %.2f m/s\n",
94.                time, bounce_count, fabs(velocity));
95.     }
96. }
98. void display_state() {
99.     // 每隔一定时间输出一次状态
100.     static int counter = 0;
101.     counter++;
102.    
103.     if (counter >= 50) {  // 每50个时间步长输出一次
104.         printf("时间: %.2f s, 位置: %.2f m, 速度: %.2f m/s\n",
105.                time, position, velocity);
106.         counter = 0;
107.     }
108. }
110. void init_graphics() {
111.     // 初始化SDL
112.     if (SDL_Init(SDL_INIT_VIDEO) < 0) {
113.         printf("SDL初始化失败: %s\n", SDL_GetError());
114.         exit(1);
115.     }
116.    
117.     // 创建窗口
118.     window = SDL_CreateWindow("落体反弹模拟",
119.                              SDL_WINDOWPOS_UNDEFINED,
120.                              SDL_WINDOWPOS_UNDEFINED,
121.                              WINDOW_WIDTH, WINDOW_HEIGHT,
122.                              SDL_WINDOW_SHOWN);
123.     if (window == NULL) {
124.         printf("窗口创建失败: %s\n", SDL_GetError());
125.         exit(1);
126.     }
127.    
128.     // 创建渲染器
129.     renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
130.     if (renderer == NULL) {
131.         printf("渲染器创建失败: %s\n", SDL_GetError());
132.         exit(1);
133.     }
134. }
136. void draw_scene() {
137.     // 清除屏幕
138.     SDL_SetRenderDrawColor(renderer, 240, 240, 240, 255);
139.     SDL_RenderClear(renderer);
140.    
141.     // 绘制地面
142.     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
143.     SDL_RenderDrawLine(renderer, 0, WINDOW_HEIGHT - 50, WINDOW_WIDTH, WINDOW_HEIGHT - 50);
144.    
145.     // 计算物体在屏幕上的位置
146.     int screen_x = WINDOW_WIDTH / 2;
147.     int screen_y = WINDOW_HEIGHT - 50 - (int)(position * SCALE);
148.    
149.     // 绘制物体
150.     SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
151.     SDL_Rect ball = {screen_x - 15, screen_y - 15, 30, 30};
152.     SDL_RenderFillRect(renderer, &ball);
153.    
154.     // 绘制高度标尺
155.     SDL_SetRenderDrawColor(renderer, 100, 100, 100, 255);
156.     for (int i = 0; i <= INITIAL_HEIGHT; i++) {
157.         int y = WINDOW_HEIGHT - 50 - (int)(i * SCALE);
158.         SDL_RenderDrawLine(renderer, 50, y, 60, y);
159.         
160.         // 绘制刻度值
161.         char text[10];
162.         sprintf(text, "%dm", i);
163.         // 这里简化处理，实际应用中应使用SDL_ttf来渲染文本
164.     }
165.    
166.     // 更新屏幕
167.     SDL_RenderPresent(renderer);
168. }
170. void close_graphics() {
171.     SDL_DestroyRenderer(renderer);
172.     SDL_DestroyWindow(window);
173.     SDL_Quit();
174. }
176. void run_simulation() {
177.     // 初始化模拟
178.     initialize_simulation();
179.    
180.     // 初始化图形
181.     init_graphics();
182.    
183.     // 模拟循环
184.     SDL_Event e;
185.     int quit = 0;
186.    
187.     while (!quit && time < 20.0) {
188.         // 处理事件
189.         while (SDL_PollEvent(&e) != 0) {
190.             if (e.type == SDL_QUIT) {
191.                 quit = 1;
192.             }
193.         }
194.         
195.         // 更新物理状态
196.         update_physics();
197.         
198.         // 检测碰撞
199.         check_collision();
200.         
201.         // 显示当前状态
202.         display_state();
203.         
204.         // 绘制场景
205.         draw_scene();
206.         
207.         // 检查是否停止弹跳
208.         if (fabs(velocity) < 0.05 && position <= GROUND_LEVEL + 0.01) {
209.             printf("物体在 %.2f 秒后停止弹跳，共反弹 %d 次\n",
210.                    time, bounce_count);
211.             
212.             // 等待几秒后退出
213.             SDL_Delay(3000);
214.             break;
215.         }
216.         
217.         // 控制帧率
218.         SDL_Delay((int)(TIME_STEP * 1000));
219.     }
220.    
221.     // 关闭图形
222.     close_graphics();
223.    
224.     printf("模拟结束\n");
225. }

复制代码

7. 总结

本教程详细介绍了如何使用C语言编写一个落体反弹物理模拟程序。我们从基本的物理原理开始，逐步构建了一个完整的模拟程序，并讨论了多种可能的改进方向。

通过这个项目，我们学习了：

1. 如何将物理原理转化为计算机程序
2. 如何使用数值积分方法模拟连续的物理过程
3. 如何检测和处理碰撞事件
4. 如何使用SDL库创建简单的图形显示
5. 如何通过添加空气阻力等效果使模拟更加真实

这个基础程序可以作为更复杂物理模拟的起点，例如扩展到二维或三维空间、添加更多物体、模拟更复杂的物理现象等。物理模拟是计算机图形学、游戏开发和科学计算中的重要组成部分，掌握这些基本技术将为您的编程之路打开新的可能性。

希望这个教程对您有所帮助，祝您编程愉快！