C语言小游戏开发实战：用EasyX从零实现Flappy Ball-代码聚汇网

C语言小游戏开发实战：用EasyX从零实现Flappy Ball

刘信华·2026-08-30·阅读 22 GEO检测（免费）

C语言图形化编程EasyX

|难度：普通|阅读约 31 分钟

很多人学到指针和结构体的时候都有这种感觉：语法都认识，例题也能看懂，但一合上书让自己写个东西就不知道从哪下手。我当时也是这个状态，直到跟着童晶老师的C语言课程做到Flappy ball这个小游戏，才第一次觉得"C语言是真的能拿来做出点东西的"。一个会飞的小球，几根柱子，一个计分器，听起来很简单，但真正亲手把它从零写出来之后，循环、随机数、碰撞检测、图形库的绘图机制、甚至模块化的代码组织方式，全都串起来了。这篇文章就是我对这一节的完整笔记，加上了我自己在实现过程中踩过的坑和思考，适合刚学完C语言基础语法、想通过一个小项目把知识落地的初学者，也适合正在带学生做C语言课程设计的同学参考。

1. 为什么是Flappy ball：这个项目到底在练什么

很多初学者在选练习项目时容易走两个极端：一个是疯狂刷题，一个是上来就挑战俄罗斯方块、贪吃蛇这种完整的小游戏。刷题的问题是知识点太碎，永远在写一些孤立的函数，很难建立"一个程序是如何组织起来"的整体感。而直接做完整游戏的问题正好相反，对初学者来说复杂度太大，光是界面框架和逻辑跳转就能把人劝退。

Flappy ball这个项目最妙的地方在于，它正好卡在"简单"和"完整"之间。从代码量看，核心逻辑大约一两百行就能跑起来，哪怕加上各种细节优化，也就三四百行。但这个体量里，它几乎覆盖了C语言入门阶段最重要的几个模块：

图形库的基本使用。窗口怎么初始化，怎么绘制圆形和矩形，怎么让画面持续刷新。
帧循环和动画机制。游戏本质上是一个不断重复的"清屏、更新状态、绘制"循环，理解了这一点，往后做任何图形程序都不慌了。
随机数的实际应用。柱子高度的随机变化，是这个游戏可玩性的来源，也是rand()函数第一次在真实场景里派上用场。
结构体的初步运用。小球有坐标、速度、半径，柱子有位置、间隙、得分标记，用结构体去组织这些属性，比用一堆零散变量清晰得多。
碰撞检测的入门实现。球撞到柱子或者超出边界就游戏结束，这个判断逻辑是后面所有动作游戏的基础。

所以不要小看这个项目。它不是"玩"出来的demo，而是从"能写语法题"到"能写程序"之间的一座很关键的桥。我当时学完这一节最大的感受是，原来我在课本上学的那些语法，不是一个个孤立的考点，而是可以组合起来解决一个完整问题的零件。

另外提一句，童晶老师的课程用的是EasyX图形库，它专门针对C/C++初学者设计，不需要额外学复杂的GUI框架，调用几个绘图函数就能在窗口上画东西。这套方案非常适合国内高校的C语言课程设计场景，学习成本低，出效果快。如果你用的是其他图形库或者纯命令行环境，思路也完全一样，核心的游戏逻辑不受影响，只是绘图函数换成对应库的接口而已。

1.1 课程的铺垫：你需要哪些前置知识

我建议在动手做这个项目之前，先把这几块基础打牢：

顺序、选择、循环三大结构。尤其是while循环，游戏主循环就是靠它撑起来的。
函数的定义与调用。哪怕很简单的功能也建议拆成函数写，这是项目能否清晰扩展的关键。
数组和结构体。柱子有多根，每根都有自己的位置和状态，用数组存、用结构体描述属性，是自然而然的做法。
rand()随机函数和time()种子。这部分很多教材放在后面，但做这个项目之前最好先自己补一下，不然遇到"每次运行柱子高度都一样"的问题会一脸懵。

如果你前面这些内容还有点模糊，建议先回去翻一翻，不用精通，知道大概是什么、能干什么就行。真正的理解会在写项目的过程中逐渐建立起来，这也是这类项目训练最核心的价值——不是教你新知识，而是让你把已有知识真正变成自己的。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 第一步：窗口、绘图与动画循环

我觉得学这个项目最好的路径，不是一开始就想着把整个游戏写完，而是先解决一个最基本的问题：怎么在屏幕上画出一个会动的小球。这个问题一旦解决，整个项目的骨架就有了，后面只是在往这个骨架上填血肉。

2.1 EasyX的初始化与基本绘图

EasyX用起来非常简单，几行代码就能打开一个窗口并画一个圆：

c复制#include <graphics.h>
#include <conio.h>

int main()
{
    // 初始化一个400x600的窗口
    initgraph(400, 600);

    // 设置填充颜色为红色，画一个实心圆
    setfillcolor(RED);
    solidcircle(200, 300, 20);

    // 按任意键关闭窗口
    getch();
    closegraph();
    return 0;
}

这里有几个概念需要明确一下。坐标系的起点在窗口左上角，x轴向右，y轴向下，所以y值越大，图形越靠近窗口底部。solidcircle的三个参数分别是圆心x、圆心y、半径。setfillcolor设置的是实心图形的填充色。

我用过的图形库不多，但EasyX这套接口设计确实很友好，它把Windows GDI那套底层封装成了"傻瓜式"调用，初学者完全不需要关心设备上下文、句柄这些概念。如果你用的是macOS或者Linux，可能没法直接装EasyX，可以换成SDL2或者直接在网页上用Canvas练，逻辑都是相通的。

2.2 让小球动起来的核心：帧循环

画出一个静止的圆很简单，但游戏要的是连续动画。动画的本质是：每秒钟刷新很多次画面，每次刷新时圆的位置稍微变一点，因为人眼的视觉暂留效应，看起来就是连续的移动。

这个"不断刷新画面"的循环，就是游戏开发里常说的主循环（game loop）。在C语言里，最直接的做法就是一个while循环：

c复制int ballX = 200;   // 球的x坐标
int ballY = 300;   // 球的y坐标
int ballVY = 0;    // 球的y方向速度
int gravity = 1;   // 重力加速度（每帧增加的速度）

while (1)
{
    // 1. 处理输入：检测有没有按键
    // 2. 更新游戏状态：根据重力计算球的新位置
    ballVY += gravity;       // 每帧速度增加一个重力值
    ballY += ballVY;         // 位置根据速度增加

    // 3. 绘制画面：先清空上一帧的内容，再画新的内容
    cleardevice();
    setfillcolor(RED);
    solidcircle(ballX, ballY, 20);

    // 4. 暂停一小会儿，控制游戏速度
    Sleep(10);
}

这段代码就是整个游戏的地基。每一次循环处理四件事：输入、更新、渲染、等待。看起来简单，但这是所有实时程序（游戏、动画、交互应用）的通用骨架，学会了这套循环思想，以后做什么图形项目都不慌。

这里我特别想提一下Sleep(10)的作用。10毫秒是100帧每秒的理论帧率上限，但实际上Windows的定时器精度没那么高，实际运行大概在60-80帧左右。不加Sleep的话，循环会跑得飞快，球会在几毫秒内飞出屏幕。这个延时就是给程序"踩刹车"的，让动画速度适合人眼观察。延时设置多长，直接决定游戏的整体速度感，可以自己调整玩一玩，比如改成5会明显变快，改成20会明显变慢。

2.3 避免闪烁：批量绘图

初学图形编程的人很容易遇到一个经典问题：画面闪烁得厉害，像霓虹灯一样。我第一次写这种循环的时候也遇到了，当时还以为是电脑配置问题，后来才知道是绘制时机没处理好。

闪烁的原因很简单：程序先把画面清空成黑屏，然后才把球画上去。如果这个过程发生在屏幕上，人眼就会在极短的时间内看到"黑屏、画面、黑屏、画面"的交替，视觉上就是闪。

解决办法是双缓冲，也叫批量绘图。思路是先在一块隐藏的"画布"上画好所有的内容，等全部画完之后，一次性把整块画布显示在屏幕上。这样屏幕永远不会出现"只画到一半"的状态，闪烁自然就消失了。

EasyX里提供了现成的三个函数：

c复制BeginBatchDraw();   // 开始批量绘图，之后画的都不会立刻显示

while (1)
{
    cleardevice();
    // ... 绘制所有内容 ...
    FlushBatchDraw();  // 把隐藏画布一次性显示到屏幕
    Sleep(10);
}

EndBatchDraw();   // 结束批量绘图

你只管在循环前调用BeginBatchDraw()，每帧绘制完后调用FlushBatchDraw()，剩下的交给你背后的Windows GDI去处理。

这个事情放到游戏开发领域，其实是一个通行方案。很多成熟的游戏引擎，比如Unity、Unreal，底层渲染默认就是用类似的机制来避免画面撕裂和闪烁。你在小项目里先体会到这个问题的存在和解决方法，以后接触更复杂的东西时会很有帮助。

3. 小球飞舞的核心：重力、速度与按键响应

动画循环有了，球可以动了，但现在的运动是单纯的自由落体——球会一直往下掉，飞出屏幕。要成为一个游戏，必须加入玩家的交互：按一下空格，球就向上跳一下；不按，球就继续受重力往下落。这个"跳跃+下落"的节奏感，正是Flappy ball这个游戏的全部核心玩法。

3.1 用速度变量实现重力

物理模拟是很多初学者觉得"高大上"的东西，但其实只需要两个变量就能做出非常像样的重力效果：位置和速度。

重力表现为"每帧给速度增加一个固定的值"。比如重力加速度gravity = 1，那么每一帧，球的下落速度就会快1个单位。
位置则等于"当前的位置加上当前的速度"。球的速度越大，每一帧移动的距离越远，看起来就是越落越快。

用代码写出来就是：

c复制ballVY += gravity;    // 速度受重力影响，越来越大
ballY += ballVY;      // 位置根据速度改变

这个方案在物理上其实就是最简单的积分：速度是位置的导数，加速度是速度的导数，每一步用固定帧步长去近似。对于一个小游戏来说，这样的精度完全够用，不需要引入复杂的运动学公式。

我这里用了一个生活化的类比：想象你站在一个自动扶梯上，扶梯的速度在不断增加，你每秒走过的距离也就越来越多。这个扶梯的加速就是重力，你的位置变化就是ballY += ballVY。

3.2 按键跳跃的实现

接下来是跳跃。跳跃的本质是：当玩家按下空格键的瞬间，给球一个向上的速度（也就是一个负的y方向速度），抵消掉重力带来的下落趋势，球就会弹起来。

在EasyX环境下，检测按键有几种方法。最简单的就是getch()，但它有一个问题：getch()是阻塞式的，意思是没有按键的时候程序会卡在那里等，我们的动画循环就停了。所以更合适的做法是先用_kbhit()判断"有没有按键"，有的话再用getch()取出来：

c复制if (_kbhit())
{
    char key = getch();
    if (key == ' ')
    {
        ballVY = -10;   // 给球一个向上的初速度
    }
}

_kbhit()全称是keyboard hit，就是"键盘是否有输入"的意思。这个写法在实时程序中很常见——不阻塞主循环，只在有输入的时候去处理。这也是游戏引擎里事件系统的一个最基本的雏形：循环每帧检查一次事件队列，有事件就处理，没事件就继续跑。

跳跃速度给多少是个经验值，我一开始设的-8，发现球跳得太矮，很快就掉下来了，游戏节奏过于紧张。改成-12，球又飞得太高，按一次键得等半天才落下来。最后调到-10左右，再配上gravity = 1和Sleep(10)，手感才比较舒服。这个调参的过程，其实就是所谓"手感调优"的入门，很多独立游戏开发者花大量时间调的就是这种东西。

3.3 边界处理：掉下去就结束

球不能无限往下掉，这个游戏至少需要有个失败条件。最基础的版本可以设定：如果球的y坐标超出窗口下边界，游戏结束。

c复制if (ballY > HEIGHT - 20)  // HEIGHT是窗口高度，20是球的半径
{
    printf("游戏结束！你的得分：%d\n", score);
    break;
}

这里要注意一个细节，很多初学的人写判断时会写成ballY > HEIGHT，但球的圆心到了窗口下边界时，球的半径部分已经超出屏幕了。为了让"球完全掉出屏幕"才判定失败，更合理的判断是ballY > HEIGHT + 20，或者至少是ballY > HEIGHT - 20。这个"留出半径余量"的思路，在碰撞检测里非常重要，后面的柱子判定也会用到。

4. 障碍物的生成、移动与碰撞检测

小球能飞能落了，接下来要做的就是游戏里最核心的部分——柱子。柱子横在飞行路线上，球必须从两根柱子之间的缝隙穿过去，穿过去得一分，碰到柱子或者飞出上下边界就算输。

4.1 用结构体组织柱子的属性

游戏里不能只有一根柱子，经典Flappy Bird是有连续多根柱子依次出现的。每一根柱子都有自己的x坐标（会不断向左移动）、中间缝隙的位置（随机生成），以及一个"是否已经得过分"的标记。把这些属性凑在一起，天然就是一个结构体：

c复制struct Pipe
{
    int x;          // 柱子的x坐标
    int gapY;       // 缝隙中心的y坐标
    int scored;     // 是否已经计过分数，0或1
};

用结构体有两个好处。一是代码可读性好，看到pipe.x就知道是柱子的x坐标，不用记一堆分散的变量名。二是方便后面用数组管理多根柱子，pipe[0]、pipe[1]……每一根都有自己的独立状态。

如果你学到C语言课程期末阶段，可能会在"学生成绩管理系统"这类作业里用过结构体，那这个项目里把它用于游戏对象，会是一种完全不同的感受——结构体不只是用来存数据的，更是用来描述"一个正在运动的事物"的。

4.2 多根柱子的循环复用

理论上讲，柱子可以不停地从右边生成，然后向左移动。但如果柱子数量无限增长，程序内存终究会被耗尽。更聪明的做法是：固定使用3-4根柱子，让它们循环着"从右边回到屏幕里"。

具体思路是：

初始化3根柱子，均匀分布在屏幕上。
每帧所有柱子x坐标减一个固定值（向左移动）。
当某根柱子的x坐标出了一屏（比如x < -50），就把它重新放到屏幕最右边，并随机生成一个新的缝隙高度。

这样做的好处是，内存占用恒定的，代码也不复杂，而且效果和无限柱子完全一样。这个"对象池"的概念在小游戏里非常常见，所有物体都是预先创建好，只做位置和状态的循环复用。

代码大概是这个意思：

c复制#define PIPE_COUNT 4

struct Pipe pipes[PIPE_COUNT];

// 初始化
for (int i = 0; i < PIPE_COUNT; i++)
{
    pipes[i].x = WIDTH + i * 150;
    pipes[i].gapY = rand() % (HEIGHT - 200) + 100;
    pipes[i].scored = 0;
}

// 每帧移动
for (int i = 0; i < PIPE_COUNT; i++)
{
    pipes[i].x -= 3;

    if (pipes[i].x < -50)
    {
        pipes[i].x = WIDTH + 50;
        pipes[i].gapY = rand() % (HEIGHT - 200) + 100;
        pipes[i].scored = 0;
    }
}

这里面150是柱子之间的间隔距离，3是每帧移动速度，这两个参数直接决定游戏难度：间隔越小、速度越快，球越难穿过去。我这里给的数值比较适合初学者，跑起来感觉挺舒服的。

4.3 绘制柱子：上下两段矩形

柱子的绘制比球稍微麻烦一点，因为每一根柱子实际上是由两个矩形组成的：上段从上边界一直延伸到缝隙上方，下段从缝隙下方一直延伸到下边界。

先设定一个缝隙高度，比如120像素。那么：

上段矩形：左上角为(pipes[i].x, 0)，右下角为(pipes[i].x + PIPE_WIDTH, pipes[i].gapY - GAP_HEIGHT / 2)。
下段矩形：左上角为(pipes[i].x, pipes[i].gapY + GAP_HEIGHT / 2)，右下角为(pipes[i].x + PIPE_WIDTH, HEIGHT)。

用EasyX的fillrectangle函数很容易画出来：

c复制setfillcolor(GREEN);

// 上柱
fillrectangle(pipes[i].x, 0, pipes[i].x + PIPE_WIDTH, pipes[i].gapY - GAP_HEIGHT / 2);
// 下柱
fillrectangle(pipes[i].x, pipes[i].gapY + GAP_HEIGHT / 2, pipes[i].x + PIPE_WIDTH, HEIGHT);

这里PIPE_WIDTH是柱子的宽度，我设的是50像素。缝隙高度GAP_HEIGHT设的是130像素。这两个参数都是可调的，调小点就是地狱难度，调大点就是养老模式。

4.4 碰撞检测：圆和矩形的相交判断

碰撞检测是整个游戏里最需要动脑子的地方。球是一个圆形，柱子是矩形，怎么判断两者是否碰撞？

有一个非常通用的思路：先找到矩形上离圆心最近的那个点，然后计算这个点到圆心的距离。如果这个距离小于圆的半径，说明碰撞了；否则没有。

"矩形上离圆心最近的点"怎么找？其实很简单，就是分别把圆心的x和y坐标"钳制"到矩形的范围内：

c复制int nearestX = ballX;
if (ballX < pipeX) nearestX = pipeX;
if (ballX > pipeX + PIPE_WIDTH) nearestX = pipeX + PIPE_WIDTH;

int nearestY = ballY;
if (ballY < pipeTop) nearestY = pipeTop;
if (ballY > pipeBottom) nearestY = pipeBottom;

int dx = ballX - nearestX;
int dy = ballY - nearestY;
if (dx * dx + dy * dy < ballRadius * ballRadius)
{
    // 碰撞了，游戏结束
}

这个方法之所以好用，是因为它把复杂的"圆形和矩形相交"问题，转化成了一个"点和点的距离"问题，只需要几行简单的比较和乘方运算就能解决，不需要任何复杂的数学公式。而且它判断得很准，比用"圆心是否在矩形内部"这种简化的判定要可靠得多。

这个"钳制最近点"的思路在2D游戏开发里非常通用，往后做任何涉及圆形碰撞的场景都可以直接搬过去用。

4.5 计分逻辑

计分是最容易写错的地方。很多新手会想成"每穿过一根柱子加一分"，但怎么判断"穿过"呢？判断条件其实就是：球和柱子的x坐标之间的相对关系。

最常用的方案是：当球的x坐标超过了柱子的x坐标（说明球已经飞过这根柱子了），并且这根柱子还没被计过分，就加一分，然后把scored标记设为1，防止重复计分。

c复制for (int i = 0; i < PIPE_COUNT; i++)
{
    if (pipes[i].scored == 0 && ballX > pipes[i].x + PIPE_WIDTH)
    {
        score++;
        pipes[i].scored = 1;
        printf("得分：%d\n", score);
    }
}

注意判断条件是ballX > pipes[i].x + PIPE_WIDTH，也就是球的x坐标已经超过了柱子的右边缘，而不是柱子的左边缘。如果用后者，球还在柱子里的时候就开始计分了，视觉上感觉"穿了一半就得分"，很别扭。这个细节看似小，但对游戏体验的影响非常直接。

还有一个容易踩的坑：如果柱子循环复用了，scored标记必须复位。不然柱子从右边重新进入屏幕时，它仍然是"已经计过分"的状态，玩家穿过去死活不加分。我第一次做的时候就没注意这个问题，测试了半天才发现原来是漏了这个重置操作。

5. 从课程demo到工程化：代码组织与参数调优

跟着教程把代码连起来跑通之后，我并没有到此为止。因为我发现，照着教程写出来的代码全部堆在main函数里，虽然能运行，但一旦要加新功能或者改参数，就非常痛苦。于是我开始尝试用工程化的思路重新组织代码，这个过程带来的收获甚至比做游戏本身还大。

5.1 合理拆分函数：每个函数只干一件事

我最终的代码拆成了下面几个函数，每个函数只负责一件清晰的事情：

initGame()：初始化窗口、小球、柱子的初始状态。
updateInput()：处理每一帧的按键输入。
updateLogic()：更新小球的位置、速度，柱子的移动和循环，碰撞检测和计分。
drawGame()：绘制背景、小球、柱子、得分信息。
gameOver()：处理游戏结束后的收尾和提示。

这样做的好处是，你随时可以单独看某一块逻辑，比如想改碰撞检测，只需要看updateLogic里那一个函数；想调整画面颜色，只看drawGame。main函数只需要在游戏主循环里依次调用这几个函数，整个程序的结构一目了然。

很多人学到C语言课程的中后段会接触到"模块化程序设计"的概念，但在练习题和考试题里往往体会不到它的实际价值。在这个小游戏项目里，只要代码超过150行，函数拆分的价值就会立刻显现出来。我建议初学者即使照着教程写，也要有意识地把功能分到函数里，而不是全部挤在main里面。

5.2 用宏定义集中管理魔法数字

我第一次写的时候，代码里到处都是赤裸裸的数字：400、600、20、3、130、50……后来想改参数，得满篇找，有的地方忘了改，整个游戏就变得很奇怪。这个问题在编程里叫"魔法数字"，正规做法是用宏定义或者常量把核心参数集中管理。

我用宏定义把它们全部定义在文件开头：

c复制#define WIDTH        400
#define HEIGHT       600
#define BALL_RADIUS  20
#define GRAVITY      1
#define JUMP_SPEED   10
#define PIPE_WIDTH   50
#define GAP_HEIGHT   130
#define PIPE_SPEED   3
#define PIPE_COUNT   4
#define PIPE_DISTANCE 150

改起来就非常方便了。比如我想把游戏调难一点，只需要把GAP_HEIGHT改成100，或者把PIPE_SPEED改成5，重新编译运行，就能立刻感受到难度变化。这种"改一个数字，试一次手感"的快速迭代方式，让我对游戏参数的理解深入了很多，也让我第一次体会到"代码可维护性"这件事是真实存在的，不是书本上的空话。

5.3 参数调优：让手感更接近经典Flappy Bird

调试的过程中我个人最喜欢干的事情，就是琢磨这套物理参数。有一次我专门查了经典Flappy Bird的参数，发现那款游戏的物理设定大致是：屏幕分辨率288x512，玩家上升的速度大约是每秒-250像素左右，重力加速度大概是每秒900像素秒方，柱子间隙约150像素，柱子移动速度约每秒130像素。

把这些参数换算成EasyX的每帧逻辑，其实和我上面给的数值差别很大，因为帧率不同、屏幕比例不同，不能直接抄。但有一个调参的思路很值得参考：

先固定屏幕尺寸和帧率。
确定柱子移动速度，也就是游戏的整体节奏，我习惯先让柱子每帧移动3个像素。
确定重力大小，让自由下落的速度看起来"不飘也不坠"，我试下来GRAVITY=1比较顺手。
最后调跳跃速度，使球能恰好跳到柱子间隙的高度。这个参数很敏感，差一两个数值手感就完全不同。

我自己调的时候发现一个很实用的技巧：先不管柱子，只调球的重力和跳跃，让球在屏幕里上下飞舞，手感流畅了，再加柱子。毕竟柱子是拿来当障碍物的，如果球本身的物理感觉不对，整个游戏都很难受。

5.4 移植和扩展的思考

这一节学完之后，我把小人改成了一架小飞机，柱子换成了敌机群，又加了背景滚动效果。每次改动都逼迫我去读原代码、理解原逻辑，然后再动手改。这种"在别人代码基础上做二次开发"的经验，比照着教程一步步敲一遍要值钱得多。

6. 我踩过的坑和你想问的细节问题

这部分写几个我实际排查过的问题，希望你能绕开。

6.1 球一碰柱子但没判输

有一次我改了柱子的循环复用逻辑之后，发现球明明碰到柱子了，游戏却还在继续运行。排查了很久，发现是碰撞检测里的边界算错了。

我当时写的判断条件是判断"圆心是否在柱子内部"，没有处理球半径的余量，导致球的边缘已经进了柱子、圆心还没进，所以判定不成立。后来换成前面说的"最近点距离小于半径"的方案，问题立刻解决了。这个小问题让我明白了一个道理：碰撞检测不能想当然，数学上严谨的方案才靠谱。

6.2 画面闪烁问题

我前面说了批量绘图能解决闪烁，但有一次我在代码里把FlushBatchDraw放到了Sleep之后，画面就又开始闪了。原因很直观：批量绘图要求"画完立刻显示"，如果先Sleep再显示，那么在Sleep期间窗口一直停留在上一帧的画面，等显示的时候又像"瞬移"一样跳过去，观感上就会出现类似闪烁的不连续感。

6.3 随机数不随机

这是C语言初学者几乎必踩的坑。直接调用rand()得到的随机序列，不管运行多少次，结果都一样，因为rand()用的是固定的种子。需要在程序开始时调用srand((unsigned)time(NULL))，用当前时间作为随机种子，这样每次运行才会得到不同的柱子高度。

c复制#include <stdlib.h>
#include <time.h>

srand((unsigned)time(NULL));

一个容易忽视的细节：srand只需要调用一次，不要放在主循环里。如果每帧都重新设置随机种子，而且time(NULL)返回的秒数短时间内不变，你得到的"随机"数字反而会高度相似。这是新手最容易犯的一个隐蔽错误，需要留意。

6.4 计时和帧率的控制

Sleep(10)不是精确的定时器。实际运行时，每一帧的耗时不只是Sleep的10毫秒，还包括绘图和逻辑计算的时间。如果你的逻辑比较复杂，每一帧实际可能耗时15毫秒甚至更多，游戏就会变慢。

如果在后续的进阶中意识到这个问题，可以改用GetTickCount()或者clock()来做基于时间戳的帧率控制，让游戏速度不依赖于复杂逻辑的耗时。这是从小游戏走向更严谨游戏开发的一个重要的进阶点，现阶段知道有这回事就可以了。

7. 这个项目做完之后，下一步往哪走

Flappy ball学完之后，能明显感觉到自己对C语言的掌握程度上了一个台阶。这里分享几个真实可行的进阶方向，都是基于这个项目做小改造，难度可控，又能学到新东西。

第一个方向是加背景元素。学习怎么加载图片、怎么让背景缓慢向左滚动以模拟飞行感，这会用到图像的绘制和坐标偏移，相当于对"动画"这个概念的加深理解。

第二个方向是改变物理模型。比如加入"点击屏幕持续上升"而不是"点击跳跃一下"的控制方式，这会让球的运动变得更加细腻，需要你对速度和加速度有更深的理解。

第三个方向是做声音和动画效果。游戏结束时放个特效，得分时音效不一样，这些会引入更多库函数，但代码难度并不高，适合建立成就感。

第四个方向是把代码改成面向对象风格。如果你学完了C++，可以把结构体升级成类，把相关的函数封装成方法，这会是理解"面向对象为什么能提高代码组织效率"的绝佳练习。

从教学的角度，这个项目能覆盖的C语言知识点非常密集——三大结构、函数、结构体、数组、随机数、图形库。从游戏开发的角度，它是一个麻雀虽小五脏俱全的迷你框架，理解了它的主循环和状态机，很多经典小游戏的基本结构都能看懂了。

按我自己的体会，学到这一节的时候，我第一次有了"我不是在写练习题，我是在做游戏"的实感。代码跑起来的那一刻，看着小球在屏幕上跳跃、穿柱、得分、撞柱，那种成就感是很强的。希望这份笔记能帮你少走点弯路，早点把属于你自己的Flappy ball跑起来。