C++结合EGE图形库开发恐龙跳跃游戏：从零实现完整流程

1. 从零开始用EGE19.01写一个恐龙跳跃游戏，一点都不难

我估计很多人和我一样，学C++学到指针、结构体、链表这些地方就开始犯困了，语法都背熟了但一让写个带界面的东西就抓瞎。控制台里黑底白字跑几行运算结果，实在提不起劲儿继续学下去。后来我偶然接触到了EGE这个小众但非常好用的图形库，花了一个周末用C++配合EGE19.01写了一个恐龙跳跃游戏，总算找到了“学C++还能做点啥”的感觉。

EGE的完整称呼是Easy Graphics Engine，一个专门给C/C++用的Windows图形库。它的思路很朴素，就是把常见的窗口创建、绘图、事件捕获、音频播放、帧缓冲这些底层操作封装成简单的函数。你不需要像用Win32 API那样去写消息循环、注册窗口类，也不用接触DirectX那种让人头皮发麻的COM接口。EGE把你需要在屏幕上干的事情压缩成几十个函数，学一遍基本就能上手。

今天这篇文章就把我这个恐龙跳跃游戏的完整制作过程分享出来。它不需要你有多高深的C++水平，能理解结构体、分支、循环和函数就足够。项目结构并不复杂，一共就几个模块，跑起来之后你就能看到一个卡通风格的小恐龙在屏幕上跳跃躲避仙人掌障碍物，按空格键跳跃，碰到障碍物就结束游戏。

如果你刚学完C++基础语法、想在图形化方向上练练手，或者想给自己的课设、毕设准备一个有趣的小项目，这个恐龙跳跃游戏非常合适。文章会从环境配置讲到核心逻辑，再到踩坑实录，最后说说怎么调手感，全程都基于EGE19.01这个版本来做。

2. 为什么选EGE这个“轮子”，以及环境怎么搭

2.1 选型思路：EGE、EasyX、SDL该怎么挑

在开始写代码之前，我承认自己纠结过一阵子，到底用EGE还是用EasyX，甚至想过直接用SDL。毕竟网上关于EasyX的中文资料明显更多，随便一搜就是一堆教程。但实际对比下来，EGE在某些场景下比EasyX更合适，尤其是如果你熟悉或喜欢BGI风格的老式绘图函数，EGE几乎是Perfect的平替。

EGE和EasyX最核心的区别在于：EasyX其实是在Windows GDI基础上的封装，长期维护、资料多、上手快；而EGE同样基于GDI，但它提供了更高层级的封装，包括缓冲管理、窗口设置、消息处理，整体用起来更接近Borland BGI时代的编程体验，特别适合从赵哲老师那本《C++大学教程》或各种以图形学练习为导向的教材过渡出来的学习者。而且EGE的窗口创建和延迟刷帧控制做得比EasyX更顺手一点，delay_fps这个函数在动画循环里非常顺手，能直接让画面刷新稳定在指定帧率。

SDL则是另一个维度的东西，跨平台、性能更强，但要配置SDL2的链接库、还要自己管窗口事件、渲染器，对只想快速看到一个小游戏跑起来的初学者来说门槛偏高。EGE19.01则下载即是完整的库文件，放在编译器include和lib目录里就能用，不需要什么别的依赖，这些特性合在一起，让我最终拍板用EGE。

2.2 开发环境准备与EGE19.01的下载安装

EGE的官方下载包中会同时提供各历史版本的压缩包，19.01是比较新的一个稳定版本，压缩包命名类似于 EGE19.01.7z 或带其他后缀。解压后打开文件夹，里面会看到 include、lib、doc、examples 四个主要目录，这个结构非常清爽。

我自己用的是 VS2019 的 Community 版本，如果你的电脑装的是别的IDE，比如Dev-C++、Code::Blocks、CLion，EGE在官方文档里都给了对应的配置方式。下面以VS2019示范安装步骤：

1. 下载EGE19.01压缩包，解压到你习惯的第三方库目录，比如 D:\Libs\EGE。
2. 打开VS2019，新建一个空项目（Console App即可），项目语言选C++。
3. 进入项目属性 → VC++目录 → 包含目录，填 D:\Libs\EGE\include。
4. 同一界面的库目录，填 D:\Libs\EGE\lib\vs2019（根据你的VS版本选择对应子目录，这个子目录里放着 libEGED.lib、libEGE.lib 这类文件）。
5. 在链接器 → 输入 → 附加依赖项里，手动填写 libEGED.lib 或 libEGE.lib（Debug版用带D的，Release版用不带D的）。
6. 若编译报 fatal error C1083: Cannot open include file: 'ege.h'，多半是包含目录填错了；若报 LNK1104 cannot open file 'libEGED.lib'，则是库目录没配对。

注意：EGE在Window下还依赖 gdi32.lib、user32.lib、ole32.lib 这些系统库，正常Windows SDK装了就能找到，不需要额外下载。

EGE的examples目录里自带了好几个demo，配置好环境后可以试着直接编译运行官方样例来验证库是否正常。我第一次跑的是 draw_circle 这个示例，屏幕上弹出一个圆形窗口，圆和线条都以流畅的帧率渲染出来，那一刻就知道环境没问题了。

3. 恐龙跳跃游戏的核心逻辑拆解

写游戏之前一定要把逻辑先想清楚，这比急着写代码重要得多。我习惯先在纸上画一个状态机，把这个游戏拆成几个大块。恐龙跳跃游戏的逻辑其实非常单纯，本质上就是：一个物体（恐龙）在重力作用下做垂直方向运动，一群障碍物从右往左水平移动，恐龙一旦和任意障碍物发生矩形碰撞，游戏结束。

3.1 物理模型：单变量重力跳跃

大多数2D平台跳跃游戏里的跳跃物理，都可以简化成一个变量：垂直速度vy。这样理解起来就非常直观了：

• 恐龙在地面上时，按空格键，游戏把 vy 设置成一个负值（因为屏幕坐标系y向下为正，负值表示向上）。
• 每一帧更新位置时，y += vy。
• 每一帧更新速度时，vy += gravity。这个重力加速度是一个正的常数，让恐龙在上升过程中速度不断减小，直到变为0，然后反向加速下落。

这个模型虽然普通，但胜在简单、手感直接。通过调节 jumpVelocity 和 gravity 这两个值，就能很好地调整跳跃高度和滞空时间。这就是所谓的“手感”。

为了控制跳跃的频率，还需要一个逻辑上的限制：只有当恐龙处于地面状态时才能按空格起跳，不能让它在半空中再次起跳。否则玩家连续按两下空格，恐龙会像火箭一样直冲天花板。这个状态在代码里就是一个 bool isJumping 或者类似 isOnGround 的布尔变量。

3.2 障碍物移动模型：相对运动制造假移

障碍物（我用的是仙人掌造型，你也可以画成别的）本身没有x方向的速度，而是每一帧让所有障碍物的x坐标同时减去一个 scrollSpeed 值。为什么是“让物体动”而不是“让恐龙动”？因为画面里需要固定的背景参照物，用相对运动的方法能大幅降低逻辑复杂度，这也是横版跑酷游戏最常见的做法。

障碍物的生成没有采用工整的等距排布，那样太死板没难度。我设置了一个随机间隔函数：每次生成障碍物时，根据当前距离下一次生成的计时器小于零，就在屏幕右侧某个固定x坐标处生成一个障碍物，并重置一个随机数作为下一次生成间隔。这样仙人掌的分布就有些松紧变化，玩起来有点节奏感。

3.3 碰撞检测：AABB矩形重叠判断

AABB（Axis-Aligned Bounding Box）是游戏开发里的基础概念，简单来说就是用“边和坐标轴对齐的矩形”来表示物体的碰撞区域。EGE里绘图通常也用矩形，所以天然适合用AABB来做碰撞检测。

恐龙和障碍物各自维护一个碰撞矩形，可以是整个图像的大小，也可以适当内缩几像素，这样视觉上看起来“擦肩而过”但其实没有触发碰撞，给玩家留一点容错空间。矩形碰撞的判断条件不复杂，只要同时满足水平方向有重叠并且垂直方向有重叠，就认为两者相撞了。判断方式实际上就是两矩形边界比较，具体代码后面贴。

3.4 游戏状态机：画面里的“待机-运行-结束”切换

游戏至少要区分三种状态：菜单/待机、游戏中、游戏结束。我用了最简单的枚举类型来管理：GameState 里包含 MENU、RUNNING、OVER 三个值。主循环里根据状态决定要做什么，菜单时显示“按空格开始”，RUNNING时更新和绘制，OVER时显示分数并提示“按R重新开始”。

状态机的好处是逻辑清晰、不会乱。比如碰撞发生后你只需把状态切换到OVER，恐龙就不再更新位置，障碍物也不再移动，背景就冻结在碰撞的那一帧上，玩家能清楚地看到发生碰撞的位置。这种做法比直接退出程序要友好得多。

4. 手把手写好恐龙跳跃游戏的C++代码

4.1 游戏窗口与主循环框架

写EGE代码的第一步就是初始化窗口。EGE里创建窗口的函数是 initgraph，需要传入宽、高和窗口标志。我选的窗口是800x400，符合2D横版跑酷游戏典型的宽高比例。下面是一个最小可运行的EGE主循环框架：

cpp复制#include <graphics.h>
#include <ege.h>

int main()
{
    const int WIN_W = 800;
    const int WIN_H = 400;
    initgraph(WIN_W, WIN_H);
    
    bool running = true;
    while (running)
    {
        // 处理消息
        while (mousemsg())
        {
            mouse_msg msg = getmouse();
            if (msg.is_left() && msg.is_down())
                running = false;
        }
        
        // 更新逻辑
        
        // 绘制
        cleardevice();
        // ... 画恐龙、画障碍物、画背景
        
        delay_fps(60);
    }
    
    closegraph();
    return 0;
}

代码里 mousemsg() 和 getmouse() 负责捕获鼠标消息，delay_fps(60) 则是EGE自带的一个休眠函数，它会根据程序实际执行时间自动调节延迟，让循环尽量稳定在60帧。stdio库和graphics.h头文件是必须的，ege.h 里包含了更完整的EGE封装。

4.2 恐龙类：坐标、绘制与跳跃

我用一个结构体来保存恐龙的状态，而不是一上来就定义class。对于这种小型项目，struct足够清晰，而且改动起来灵活。恐龙包含位置坐标、速度、尺寸、所在状态：

cpp复制struct Dino
{
    float x, y;       // 左上角坐标
    float vy;         // 垂直速度
    float w, h;       // 宽度和高度
    bool isJumping;   // 是否处于跳跃状态
};

const float GROUND_Y = 320;      // 地面所在的y坐标
const float GRAVITY = 0.5f;      // 重力加速度
const float JUMP_VEL = -12.0f;   // 起跳初速度

当按下空格键时，检查 dino.isJumping，如果当前在地面则设置 vy = JUMP_VEL; isJumping = true;。每帧更新逻辑如下：

cpp复制void updateDino(Dino& dino)
{
    if (dino.isJumping)
    {
        dino.vy += GRAVITY;          // 重力作用
        dino.y += dino.vy;           // 位置更新
        if (dino.y >= GROUND_Y)       // 落到地面
        {
            dino.y = GROUND_Y;
            dino.vy = 0;
            dino.isJumping = false;
        }
    }
}

画恐龙用的是EGE的 bar 函数，这个函数画的是带边框的填充矩形。为了让恐龙看起来不那么死板，我画了一个身体矩形和一条腿，腿部随动画帧交替状态。严格来说这还不算精灵动画，但比单帧矩形有生气多了。

4.3 障碍物管理和生成节奏

障碍物我用一个vector来管理，原因是障碍物数量动态变化，数组不好处理。游戏开始后每隔若干帧就生成一个新的仙人掌，老的仙人掌不断向左移动，移出屏幕左侧之后就直接从vector里移除，避免越积越多消耗内存。

cpp复制struct Cactus
{
    float x, y;
    float w, h;
};

std::vector<Cactus> cacti;
float genTimer = 0;

void spawnLogic(std::vector<Cactus>& cacti, float dt)
{
    genTimer -= dt;
    if (genTimer <= 0)
    {
        Cactus c;
        c.w = 30;
        c.h = 50 + rand() % 40;   // 随机高度，增加视觉变化
        c.x = 800;               // 从屏幕右边缘出现
        c.y = GROUND_Y - c.h;
        cacti.push_back(c);
        genTimer = 1.0f + rand() % 80 / 10.0f;   // 1.0~9.0秒间隔
    }
}

这里我把生成间隔设成了1到9秒，随机性很大。实际玩的时候会发现有时候半天不出障碍物，有时候出来两三连发。具体间隔要根据滚动速度来调，通常是滚动速度越快、生成间隔越短，难度也越高。我最后把间隔收敛在1.5~4秒之间，这个区间比较考验反应又不会让人摔键盘。

障碍物移动就比较直白了：

cpp复制for (auto& c : cacti)
{
    c.x -= scrollSpeed * dt;
}
cacti.erase(std::remove_if(cacti.begin(), cacti.end(),
            [](const Cactus& c){ return c.x + c.w < 0; }), cacti.end());

std::remove_if配合lambda表达式是C++11之后的标准做法，一个语句就能把vector里坏掉的元素全部挪到尾部并统一erase，非常高效。这段代码如果你不熟悉STL会有点懵，但别担心，你也可以用循环加迭代器来做，效果完全一样。

4.4 碰撞检测：内缩一点更公平

AABB矩形重叠的判断，我封装成了一个函数。为了手感好一点，检测用的矩形不是完整绘图矩形，而是略微内缩了8个像素左右，这样玩起来不会出现“明明没碰到结果死了”的憋屈感。

cpp复制bool checkHit(const Dino& dino, const Cactus& c)
{
    float dinoL = dino.x + 8;
    float dinoR = dino.x + dino.w - 8;
    float dinoT = dino.y + 4;
    float dinoB = dino.y + dino.h;

    float cL = c.x;
    float cR = c.x + c.w;
    float cT = c.y;
    float cB = c.y + c.h;

    return !(dinoR < cL || dinoL > cR || dinoB < cT || dinoT > cB);
}

这个判断逻辑用的是逆否命题思路：如果两个矩形不相交，那么其中一个必然在另一个的上方、下方、左方或右方。四个条件只要有一个成立就说明不相交，所以取反的 !() 就是相交了。思路简单且不会有边界漏判。

4.5 计分系统：让游戏有目标

单纯的跳跃躲避很难让人玩超过两分钟，加一个计分系统会立刻让挑战性上来。我的计分方式是计时制：每秒钟自动加一份。比按距离计分好写，玩家心理上也能接受。为了提高挑战性，我还让 scrollSpeed 随时间缓慢增加，到后期仙人掌的移动速度越来越快，游戏难度自然提升。

分数显示用EGE的 outtextxy 或者更省事的 xyprintf，这个函数是EGE封装好的格式化输出，把数字格式化成字符串再画在窗口左上角，不需要自己处理std::string和char*的转换问题。

5. 完整实现与细节打磨

5.1 把前面所有模块组装起来

下面这个代码块是当时调试到能玩状态的核心版本，我稍微整理了一下排版方便阅读。这个版本里我把恐龙绘制、障碍物管理、碰撞处理、计分都放进了主循环，方便理解每一部分是怎么协同工作的：

cpp复制#include <graphics.h>
#include <ege.h>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>

const int WIN_W = 800;
const int WIN_H = 400;
const float GROUND_Y = 320;
const float GRAVITY = 0.5f;
const float JUMP_VEL = -12.0f;
const float BASE_SPEED = 3.0f;

struct Dino { float x, y, vy, w, h; bool isJumping; };
struct Cactus { float x, y, w, h; };

enum GameState { MENU, RUNNING, OVER };

int main()
{
    initgraph(WIN_W, WIN_H);
    srand((unsigned)time(nullptr));

    std::vector<Cactus> cacti;
    Dino dino{ 120, GROUND_Y - 50, 0, 50, 50, false };
    GameState state = MENU;
    float genTimer = 2.0f;
    float scrollSpeed = BASE_SPEED;
    float score = 0;
    float gameTimer = 0;

    while (true)
    {
        // 键盘事件
        while (kbhit())
        {
            key_msg key = getkey();
            if (key.msg == key_msg_down)
            {
                if (key.key == key_space)
                {
                    if (state == MENU)
                        state = RUNNING;
                    else if (state == RUNNING)
                    {
                        if (!dino.isJumping)
                        {
                            dino.vy = JUMP_VEL;
                            dino.isJumping = true;
                        }
                    }
                }
                else if (key.key == key_r && state == OVER)
                {
                    // 重置游戏
                    dino = { 120, GROUND_Y - 50, 0, 50, 50, false };
                    cacti.clear();
                    genTimer = 2.0f;
                    scrollSpeed = BASE_SPEED;
                    score = 0;
                    state = RUNNING;
                }
            }
        }

        // 更新
        if (state == RUNNING)
        {
            // 恐龙物理
            if (dino.isJumping)
            {
                dino.vy += GRAVITY;
                dino.y += dino.vy;
                if (dino.y >= GROUND_Y - dino.h)
                {
                    dino.y = GROUND_Y - dino.h;
                    dino.vy = 0;
                    dino.isJumping = false;
                }
            }

            // 生成障碍物
            genTimer -= 0.016f;
            if (genTimer <= 0)
            {
                Cactus c;
                c.w = 30;
                c.h = 50 + rand() % 40;
                c.x = WIN_W;
                c.y = GROUND_Y - c.h;
                cacti.push_back(c);
                genTimer = 1.5f + (rand() % 25) / 10.0f;
            }

            // 障碍物移动与移除
            for (auto& c : cacti)
                c.x -= scrollSpeed;
            cacti.erase(std::remove_if(cacti.begin(), cacti.end(),
                [](const Cactus& c){ return c.x + c.w < 0; }), cacti.end());

            // 分数
            gameTimer += 0.016f;
            score = gameTimer;

            // 难度递进
            scrollSpeed = BASE_SPEED + score * 0.05f;

            // 碰撞
            for (const auto& c : cacti)
            {
                if (checkHit(dino, c))
                {
                    state = OVER;
                    break;
                }
            }
        }

        // 绘制
        cleardevice();
        setcolor(WHITE);
        line(0, GROUND_Y, WIN_W, GROUND_Y);

        if (state == MENU)
        {
            outtextxy(WIN_W / 2 - 100, WIN_H / 2, "Press SPACE to Start");
        }
        else if (state == RUNNING || state == OVER)
        {
            bar(int(dino.x), int(dino.y), int(dino.x + dino.w), int(dino.y + dino.h));
            setfillcolor(GREEN);
            for (const auto& c : cacti)
                bar(int(c.x), int(c.y), int(c.x + c.w), int(c.y + c.h));
            setfillcolor(WHITE);
            xyprintf(20, 20, "Score: %.0f", score);

            if (state == OVER)
                outtextxy(WIN_W / 2 - 100, WIN_H / 2, "Game Over! Press R to Restart");
        }

        delay_fps(60);
    }

    closegraph();
    return 0;
}

注意这段代码里的 checkHit 函数需要在main之前定义好，或者放在头文件里，否则编译阶段就会报找不到函数。另外 setfillcolor 要记得在画矩形之前调用，bar 的边框颜色是 setcolor 控制的，填充色和边框色分开设置，不然画出来的矩形颜色会和你预期不一样。

5.2 怎样让恐龙看起来更“活”一点

全用矩形画出来的恐龙确实太素了，哪怕加上了正方形眼睛也不够生动。后来我发现一个廉价但效果还不错的方案：给恐龙画两条短腿，并且在跳跃和落地时切换腿的形态。这样看起来就像恐龙在原地跑步。具体做法是定义一个 float legFrame，每十几帧切换一次，跳跃状态下两条腿并拢，地面状态下交替前后摆动。

用EGE的画线函数 line 就能画出腿部轮廓。恐龙身体是一个稍宽的矩形，头向上延伸出去一个小方块，再加上一个眼睛圆弧，效果比纯方块好得多。你甚至可以画一个锯齿状背脊，看起来就更像恐龙了。

同理，障碍物除了画成绿色矩形，还可以在矩形的左侧边缘加几条斜线代表仙人掌刺。思路是一样的：用基本图形拼接，而不是纠结于加载外部图片资源。EGE本身也支持贴图，用 putimage 可以加载PNG或BMP，但做这种小demo时直接用绘图原语就够了，性能更好，也更锻炼绘图逻辑思维。

5.3 分数与难度曲线的调整经验

难度曲线是这个游戏最影响体验的部分。我当时把难度调成“垂直于记录”：基础滚动速度是3像素/帧，每得1分速度增加0.05。也就是说，跑到第20秒时速度已经变到4像素/帧，第60秒时到了6像素/帧。看着提升不大，但因为玩家持续处于紧张状态，后期容错率会低很多。

生成间隔一开始固定2秒，后来改为 1.5 + rand() % 25 / 10.0f，这样间隔是1.5~4秒。这个范围配合速度递增，在前期给新手足够的适应时间，后期速度上来后又会产生连续出现的密集障碍物，有点像Chrome那只小恐龙的手感。

我自己在测试时有一个明显感受：如果初始速度太低，玩家会觉得游戏“慢吞吞”的，没有紧张感；但如果初始速度太高，新手连第一个障碍物都跳不过去，特别劝退。BASE_SPEED取3.0是个比较安全的值，视觉上能感觉到滚动，但单次跳跃足够跨越一个仙人掌。

6. 常见问题排查与避坑经验

6.1 编译期问题：头文件、库文件、字符编码

新手第一次跑EGE项目最容易遇到的问题就是链接错误。特别是 libEGED.lib 和 libEGE.lib 选错：Debug模式下应该用带 D 后缀的库，Release模式下用不带 D 的。如果你Debug配置下硬要链接不带D的库，某些依赖符号会找不到，报出一大堆 LNK2019 unresolved external symbol 错误，特别吓人。

还有一类中文乱码问题，主要出现在 outtextxy 输出中文时。EGE默认编码环境和项目文件编码不一致时，显示出来的文字全是乱码。解决思路有二种：要么项目设置里启用 /utf-8 编译选项，要么所有输出文本用英文。我最后抛弃了中文提示，直接用英文显示“Press SPACE to Start”之类，省心多了。如果你坚持要用中文，需要调EGE的字体设置函数，具体可以参考EGE自带的文档，但这部分确实烦人。

6.2 运行期问题：窗口闪退、帧率不稳、按键不灵

窗口一闪而过通常是初始化失败。常见原因是 initgraph 返回值没有检查，或者项目配置了控制台模式但没有调用 getch() 等待用户操作。EGE程序如果控制台窗口打开之后立刻关闭，大部分情况是因为没有进入循环或者有异常抛出。可以在main开头加一个简单的日志输出到控制台，或者直接用断点调试来看运行到哪一行崩了。

帧率不稳多半是电脑配置或窗口大小导致的。EGE里的 delay_fps(60) 用的是固定帧率，如果你在绘制循环里做了太多重活，比如每帧加载图片、创建字体对象，那就会掉帧。解决办法是尽量把资源初始化放到循环外，并控制绘图区域大小，能局部刷新就别全屏重绘。

按键不灵的另一个隐蔽原因是输入事件处理顺序。如果你在更新逻辑之前才处理键盘事件，EGE的键盘消息队列可能在某些极端情况下积压，导致空格触发多次跳跃。我的处理方式是在每帧开头就清空并处理完所有键盘消息，只在 key_msg_down 时响应一次，这样就不会出现“第二次跳跃被提前消费”的问题。

6.3 游戏体验问题：跳跃手感差、碰撞判定怪异

跳跃手感差的根源几乎都在 JUMP_VEL 和 GRAVITY 的参数搭配上。这两个值的组合决定了跳跃的高度和滞空时间，公式很简单：

跳跃高度近似为 h = (JUMP_VEL * JUMP_VEL) / (2 * GRAVITY)；

滞空时间近似为 t = 2 * |JUMP_VEL| / GRAVITY。

以我代码里的参数为例，JUMP_VEL = -12，GRAVITY = 0.5，排除像素整数取整误差，跳跃最高点大概在144像素，滞空时间48帧约0.8秒。如果你觉得跳得不够高，优先增大 JUMP_VEL 的绝对值；如果你觉得下落像羽毛一样飘，就增大 GRAVITY。

碰撞判定怪异几乎都是因为没有做矩形内缩。恐龙虽然只有50x50，但实际视觉上的身体可能只有中间一部分，直接用整个矩形的四个边去碰撞会放大判定面积。我在 checkHit 里把恐龙的左右内缩了8像素、上面内缩了4像素，障碍物保持原尺寸，这样玩家会明显感觉“判定仁慈了许多”，尤其在高难度下，这种小细节对体验的影响非常直接。

6.4 一个隐藏较深的问题：释放与状态重置不完全

游戏结束按R键重置时，我一开始只重置了恐龙坐标和障碍物列表，漏掉了 genTimer、dino.isJumping 和 dino.vy。结果就是重新开始后恐龙可能还在跳跃状态，而且第一个障碍物没过几帧就冒出来了，体验非常突兀。这个坑告诉我，任何重置逻辑都要列出所有可变状态，逐个赋值。初学者最容易忘掉布尔变量和计时器，因为它们在界面上看不出明显变化，但不重置就会导致行为异常。

这也是为什么我建议直接把重置代码写成一个函数，比如 void resetGame(Dino& dino, std::vector<Cactus>& cacti, float& genTimer, float& scrollSpeed, float& score)，把所有要重置的参数都传进去。这样你只要在函数内部用当前参数列表逐项设为初始值，就不容易漏掉。

7. 在手感调优上的额外心得

如果你把上面那份代码跑起来，会发现它已经是一个能完整玩下去的恐龙跳跃游戏了。但“能玩”和“好玩”之间还差着一些东西，这些东西不是功能，而是手感、节奏和反馈。

一个特别容易提升体验的小改动是：在恐龙跳跃和落地时切换腿部动画的帧率。比如空中用合并的腿造型，落地后左右交替。实际上这就给玩家视觉上多了一层反馈，让“我按空格成功了”这件事变得更直观。

另一个改动是背景。虽然游戏主体是极简风格，但给背景画一条虚线、几朵云或者远处的山丘，都会让画面层次丰富起来。这些元素同样做成缓慢平移的物体，速度比障碍物移动慢一些，就能产生视差效果。视差效果会让玩家感觉场景是立体的、空间是连续的，而不是一个干巴巴的横轴滚动条。实现视差的代码其实很便宜，无非就是多维护一组x偏移量，每个元素组用自己的速度系数而已。

还有音效。EGE提供 playsound 或 sound 之类的接口，你可以在跳跃时播放一个很短的“咻”音。这个反馈在物理上可以说是对动作的“确认”，玩的时候会觉得操作更跟手。没有音频素材也没关系，用系统自带的 Beep 函数甚至能拼出简单的音效效果，让游戏不至于全程寂静。

我在项目V00里没做完整的音效和视差，不过我给后续版本留了很好的扩展接口。恐龙类是独立struct，障碍物是vector容器，难度参数抽出常量，新增功能不需要重写逻辑，只需要往里面加变量和分支就行。这种“为下一个版本留好改动余地”的意识，比游戏本身对你后续学C++帮助更大。

8. 后续还可以怎么扩展这个项目

说实话，V00版只是能跑通核心循环的骨架。同样的代码框架，后续可以演化出很多不一样的东西：比如给恐龙加一个“二段跳”机制，按两下空格触发向上冲刺再加一次；比如增加不同高度、不同速度的小鸟障碍物，让玩家需要调整跳跃时机而不是无脑按空格；比如把背景从线条改成滚动的地形贴图，让场景更丰富；再比如用结构体数组代替vector来做障碍物池，锻炼一下“对象池”的底层思维。

更进阶一些，你可以在原有代码上改成双人模式，一人控制恐龙，一人控制另一只小恐龙竞速；也可以加入道具系统，像是无敌星星、磁铁吸金币。这些功能每加一个，都是在练C++里对应的知识：对象生命周期管理、定时器、状态机、UI刷新机制。你在学C++过程中遇到的那些抽象概念，在这个小游戏里全都能找到实际用武之地。

我最深的体会是：不要等学完整本C++教材再动手写项目。掌握了变量、分支、循环、数组（甚至只需要最简单的语法），就可以开始写这种小游戏了。用一点“刻意练习”的心态，把代码里不懂的每一行都查明白，进步速度远比啃语法书快得多。

这个基于EGE19.01的恐龙跳跃游戏虽然代码不到两百行，但它串联起了C++最重要的几个基础模块，也让我第一次感受到“写出一个别人能玩的程序”的成就感。如果你也刚学完C++基础，强烈建议照着这个流程做一个自己的版本，把那些结构体、数组、事件处理彻底玩明白。