经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » 游戏设计 » 查看文章
用C语言做一个横板过关类型的控制台游戏
来源：cnblogs　　作者：KillerAery　　时间：2018/10/8 8:53:41　　对本文有异议

前言：本教程是写给刚学会C语言基本语法不久的新生们。

因为在学习C语言途中，往往只能写控制台代码，而还能没接触到图形，也就基本碰不到游戏开发。

所以本教程希望可以给仍在学习C语言的新生们能提前感受到游戏开发技术的魅力和乐趣。

游戏循环机制

下面是一个简单而熟悉的C程序。

  1. #include <stdio.h>
  3. int main() {
  4.     ....    //做一些东西
  5.     return 0;
  6. }

大部分常见的程序，基本是一套流程下来（典型的流程：输入，输出，结束）

而对于游戏程序来说，往往是一直在运行（很多游戏，即使你不动，整个游戏场景也在一直模拟着）。
因此自然而然想到用循环来实现游戏程序主体——游戏循环机制

一个简单的循环机制

  1. #include <stdio.h>
  3. int main() {
  4.     while (1) {
  5.     ....    //运算（场景数据模拟，更新等）
  6.     ....    //渲染（显示场景画面）
  7.     };
  8.     return 0;
  9. }

这样的循环机制存在一定问题：程序有时候运算量大，有时候运算量少。造成游戏帧率有时很高，有时很慢。

帧率：每秒的帧数(fps)或者说帧率表示图形处理器处理场时每秒钟能够更新的次数。帧率越高，就越流畅。

  • 这就导致有时候程序时而十分快速（动作过于顺畅），有时候就比较慢。即使慢的时候fps有30~60，而在玩家看来，这种对比会造成一种卡顿感。
  • 有时候游戏帧率过高是没必要的（例如高于屏幕刷新率或者高于人眼觉得流畅的频率），而且要消耗着更多的运行资源。

限制帧数的循环机制

为了避免帧率过高带来的不好因素，一种妥当的策略是限制帧数。

  1. #include <stdio.h>
  2. #include <windows.h>  //有关获取windows系统时间的函数在这个库
  4. int main() {
  5.     double TimePerFrame = 1000.0f/60;//每帧固定的时间差,此处限制fps为60帧每秒
  6.     //记录上一帧的时间点
  7.     DWORD lastTime = GetTickCount();
  9.     while (1) {
  10.         DWORD nowTime = GetTickCount();     //获得当前帧的时间点
  11.         DWORD deltaTime = nowTime - lastTime;  //计算这一帧与上一帧的时间差
  12.         lastTime = nowTime;                 //更新上一帧的时间点
  13.         .... //运算（场景数据模拟，更新等）
  14.         .... //渲染（显示场景画面）
  15.         //若 实际时间差 少于 每帧固定时间差，则让机器休眠 少于的部分时间。
  16.         if (deltaTime <= TimePerFrame)
  17.             Sleep(TimePerFrame - deltaTime);
  18.     };
  20.     return 0;
  21. }

DWORD——unsigned long类型，本文是用来存储毫秒数。属于<windows.h>

Sleep(DWORD ms);——函数作用：让程序休眠ms毫秒。属于<windows.h>

GetTickCount();——函数作用：获取当前时间点（以毫秒为单位），通常利用两个时间点相减来计算时间差。属于<windows.h>

这种循环机制利用时间差的计算，让每帧之间的时间限制在自己想要的固定值。
这样我们就可以利用每帧是固定时间差的原理，实现一些根据每帧时间差来做一些运算操作。

  1. //例如：我们想让一个实体在每1000毫秒20米的速度移动
  2. void update() {
  3.     //有一个速度
  4.     float speed = 20.0f / 1000.0f;
  5.     //因为每帧耗费的时间是TimePerFrame，所以我们让它移动TimePerFrame*speed米。
  6.     entity->move(TimePerFrame * speed);
  7. }

然后主函数里每帧调用更新(update)函数：

  1. while (1) {
  2.   DWORD nowTime = GetTickCount();
  3.   DWORD deltaTime = nowTime - lastTime;
  4.   lastTime = nowTime;
  6.   update();
  7.   .... //渲染（显示场景画面）
  9.   if (deltaTime <= TimePerFrame)
  10.     Sleep(TimePerFrame - deltaTime);
  11. };

看起来可行，然而事实上这是真正固定的时间差？

  • 并不是。当机器是低性能的时候，处理每帧的时间大于固定时间差时，游戏运行就会变得‘缓慢’。

例如正常运行来说，现实1000毫秒能让游戏更新60次，而60次更新能让人物移动20米。
但是由于某些机器性能低执行缓慢，1000毫秒只能让游戏更新30次，而30次更新只能让人物移动10米。

这在一些要求同步的游戏（例如网络游戏），这种情况是不应发生的，否则会造成两个玩家因为机器性能差
而看到游戏数据的不一致（例如我明明看到某个东西在A点，别人却看到在B点）。

也就是说这个循环机制：

  • 对于过高的帧率，可以限制帧率。

  • 对于低帧率情况，则束手无策，会导致时间不同步。

可变时长的循环机制

要解决时间不同步的问题，其实只需要改一点东西即可解决。

对于更新函数，我们要求一个时间差参数。

  1. //例如：我们想让一个实体在每1000毫秒20米的速度移动
  2. void update(float deltaTime) {
  3.     //有一个速度
  4.     float speed = 20.0f / 1000.0f;
  5.     //因为每帧之间实际耗费的时间是deltaTime，所以我们让它移动deltaTime*speed米。
  6.     entity->move(deltaTime * speed);
  7. }

给更新(update)等函数传入实际的时间差：

  1. while (1) {
  2.   DWORD nowTime = GetTickCount();
  3.   DWORD deltaTime = nowTime - lastTime;
  4.   ....
  5.   update(deltaTime);   //传入实际的时间差
  6.   ....
  7. };

是的，就这样解决了。
即使是低性能的机器，画面卡顿，但是能看到的数据信息也是根据实际运行时间来同步的。

游戏场景

有场景才有万物。自然而然想到第一个事情是如何构建场景。

我们设定，这是一个长为250，高为15的带重力的世界，有1X1大小的障碍物，
里面有10个怪物+1个玩家（总共11个实体）。

  1. #define MAP_WIDTH 250
  2. #define MAP_HEIGTH 15
  3. #define ENEMYS_NUM 10
  4. #define ENTITYS_NUM (ENEMYS_NUM+1)
  6. //....待补充的类型声明
  8. struct Scene{
  9.     Entity eneities[ENTITYS_NUM];    //场景里的所有实体
  10.     bool barrier[MAP_WIDTH][MAP_HEIGTH];   //障碍：我们规定假如值为false，则没有障碍。
  11.                                                       //假如值为true，则有障碍。
  12.     Entity* player;    //提供玩家实体的指针，方便访问玩家
  13.     float gravity;     //重力
  14. };

根据初步设定的场景，我们要补充相应的类型声明。

  1. //二维坐标/向量类型
  2. struct Vec2{
  3.     float x;
  4.     float y;
  5. };
  7. //区分玩家和敌人的枚举类型
  8. enum EntityTpye{
  9.     Player = 1,Enemy = 2
  10. };
  12. //实体类型
  13. struct Entity{
  14.     Vec2 position;  //位置
  15.     Vec2 velocity;  //速度
  16.     EntityTpye tpye; //玩家or敌人
  17.     char texture;    //纹理（要显示的图形）
  18.     bool grounded;   //是否在地面上（用于判断跳跃）
  19.     bool active;     //是否存活
  20. };

然后先写好一个初始化场景的函数：

  2. void initScene(Scene* scene){
  3.     //障碍初始化
  4.     bool(*barr)[15] = scene->barrier;
  5.     //所有地方初始化为无障碍
  6.     for (int i = 0; i < MAP_WIDTH; ++i)
  7.         for (int j = 0; j < MAP_HEIGTH; ++j)
  8.             barr[i][j] = false;
  9.     //地面也是一种障碍，高度为0
  10.     for (int i = 0; i < MAP_WIDTH; ++i)
  11.         barr[i][0] = true;
  12.     //自定义障碍
  13.     barr[4][1] = barr[4][2] = barr[4][3] = barr[5][1] = barr[5][2]= barr[6][1]
  14.     = barr[51][3] = barr[52][3] = barr[53][3] = barr[54][3] = barr[55][3] = barr[56][3]= barr[57][3]
  15.     = true;
  16.     //敌人初始化
  17.     for (int i = 0; i < ENTITYS_NUM-1; ++i) {
  18.         scene->eneities[i].position.x = 5.0f + rand()%(MAP_WIDTH-5);
  19.         scene->eneities[i].position.y = 10;
  20.         scene->eneities[i].velocity.x = 0;
  21.         scene->eneities[i].velocity.y = 0;
  22.         scene->eneities[i].texture = '#';
  23.         scene->eneities[i].tpye = Enemy;
  24.         scene->eneities[i].grounded = false;
  25.         scene->eneities[i].active = true;
  26.     }
  27.     //玩家初始化
  28.     scene->player = &scene->eneities[ENTITYS_NUM-1];
  29.     scene->player->position.x = 0;
  30.     scene->player->position.y = 15;
  31.     scene->player->velocity.x = 0;
  32.     scene->player->velocity.y = 0;
  33.     scene->player->texture = '@';
  34.     scene->player->tpye = Player;
  35.     scene->player->active = true;
  36.     scene->player->grounded = false;
  37.     //设置重力
  38.     scene->gravity = -29.8f;
  39. }

游戏显示

为了让控制台画面不断刷新，我们在游戏循环里加入绘制显示的函数，用以每帧调用。

该函数使用system("cls");来清理屏幕，然后通过printf再次输出要显示的内容。

控制台输出其实是显示1个控制台屏幕缓冲区的内容。

我们可以先把要输出的字符，存进我们自己定义的字符缓冲区。
然后再将字符缓冲区的内容写入到控制台屏幕缓冲区。

  1. #define BUFFER_WIDTH 50
  2. #define BUFFER_HEIGTH 15
  4. struct ViewBuffer {
  5.     char buffer[BUFFER_WIDTH][BUFFER_HEIGTH];  //自己定义的字符缓冲区
  6. };

但是很容易发现，画面会有频繁的闪烁：
这是因为上面的操作无论是清理还是输出都是对唯一一个屏幕缓冲区进行操作。
这就导致：可能会高频地出现未完全或者空的画面（发生在屏幕缓冲区清理时或清理后还没显示完内容的短暂时刻）。

双缓冲区技术

解决闪屏问题，只需要准备2个控制台屏幕缓冲区：
当写入其中一个缓冲区时，显示另一个缓冲区。这样就避免了显示不完全的缓冲区，也就解决了闪屏现象。

但是因为printf,getch等都是用默认的1个缓冲区，所以我们得另寻其他API，所以下面将会出现一些陌生的输出函数。

首先要先定义两个控制台屏幕缓冲区：

  1. #define BUFFER_WIDTH 50
  2. #define BUFFER_HEIGTH 15
  4. struct ViewBuffer {
  5.     char buffer[BUFFER_WIDTH][BUFFER_HEIGTH];  //字符缓冲区
  6.     HANDLE hOutBuf[2];   //2个控制台屏幕缓冲区
  7. };

配上一个初始化缓冲区的函数

  1. void initViewBuffer(ViewBuffer * vb) {
  2.   //初始化字符缓冲区
  3.     for (int i = 0; i < BUFFER_WIDTH; ++i)
  4.     for (int j = 0; j < BUFFER_HEIGTH; ++j)
  5.             vb->buffer[i][j] = ' ';
  6.     //初始化2个控制台屏幕缓冲区
  7.     vb->hOutBuf[0] = CreateConsoleScreenBuffer(
  8.         GENERIC_WRITE,//定义进程可以往缓冲区写数据
  9.         FILE_SHARE_WRITE,//定义缓冲区可共享写权限
  10.         NULL,
  11.         CONSOLE_TEXTMODE_BUFFER,
  12.         NULL
  13.     );
  14.     vb->hOutBuf[1] = CreateConsoleScreenBuffer(
  15.         GENERIC_WRITE,//定义进程可以往缓冲区写数据
  16.         FILE_SHARE_WRITE,//定义缓冲区可共享写权限
  17.         NULL,
  18.         CONSOLE_TEXTMODE_BUFFER,
  19.         NULL
  20.     );
  21.     //隐藏2个控制台屏幕缓冲区的光标
  22.     CONSOLE_CURSOR_INFO cci;
  23.     cci.bVisible = 0;
  24.     cci.dwSize = 1;
  25.     SetConsoleCursorInfo(vb->hOutBuf[0], &cci);
  26.     SetConsoleCursorInfo(vb->hOutBuf[1], &cci);
  27.  }

每帧更新字符缓冲区函数和显示屏幕缓冲区函数

  1. void updateViewBuffer(Scene* scene, ViewBuffer * vb) {
  2.     //更新障碍物到字符缓冲区
  3.     int playerX = scene->player->position.x + 0.5f;
  4.     //offsetX用于 使玩家永远处在屏幕中间
  5.     int offsetX = min(max(0, playerX - BUFFER_WIDTH / 2), MAP_WIDTH - BUFFER_WIDTH-1);
  6.     for (int i = 0; i < BUFFER_WIDTH; ++i)
  7.     for (int j = 0; j < BUFFER_HEIGTH; ++j)
  8.     {
  9.         //如果没有障碍，则该位置该显示空字符。否则显示障碍字符’=’
  10.         if (scene->barrier[i + offsetX][j] == false) vb->buffer[i][j] = ' ';
  11.         else vb->buffer[i][j] = '=';
  12.     }
  13.     //更新实体到字符缓冲区
  14.     for (int i = 0; i < ENTITYS_NUM; ++i) {
  15.         int x = scene->eneities[i].position.x + 0.5f;
  16.         int y = scene->eneities[i].position.y + 0.5f;
  17.     //如果实体存活并且实体的位置在屏幕能看见的范围，则显示实体纹理字符
  18.         if (scene->eneities[i].active == true && offsetX <= x && x < MAP_WIDTH) {
  19.             vb->buffer[x - offsetX][y] = scene->eneities[i].texture;
  20.         }
  21.     }
  22. }
  24. void drawViewBuffer(Scene* scene ,ViewBuffer * vb) {
  25.     //先根据场景数据，更新字符缓冲区数据
  26.     updateViewBuffer(scene,vb);
  27.     //再将字符缓冲区的内容写入其中一个屏幕缓冲区
  28.     static int buffer_index = 0;
  29.     COORD coord = { 0,0 };
  30.     DWORD bytes = 0;
  31.     for (int i = 0; i < BUFFER_WIDTH; ++i)
  32.     for (int j = 0; j < BUFFER_HEIGTH; ++j)
  33.     {
  34.         coord.X = i;
  35.         coord.Y = BUFFER_HEIGTH - 1 - j;
  36.         WriteConsoleOutputCharacterA(vb->hOutBuf[buffer_index], &vb->buffer[i][j],1, coord, &bytes);
  37.     }
  38.     //显示 写入完成的缓冲区
  39.     SetConsoleActiveScreenBuffer(vb->hOutBuf[buffer_index]);
  40.   //下一次将使用另一个缓冲区
  41.     buffer_index = !buffer_index;
  42. }

游戏输入

常见的C输入函数scanf,getch等都是属于阻塞形输入，即没有输入则代码不会继续往下执行。

但在游戏程序里几乎见不到阻塞形输入，因为即使玩家不输入，游戏也得继续运行。
这时候我们可能需要一些即使没有输入，代码也会往下执行的函数。

异步键盘输入

异步键盘输入函数是<windows.h>提供的。
它在相应按键按下时，第15位设为1；若抬起，则设为0。
利用判断该函数返还值 & 0x8000的值 是不是为真，来判断当前帧有没有按下按键。

示例用法 ：
if (GetAsyncKeyState(VK_UP) & 0x8000) {...}
//VK_UP可改成其他VK_XX代表键盘的按键

下面是本文游戏的输入处理函数：

  1. //处理输入
  2. void handleInput(Scene* scene) {
  3.     //如果玩家死亡，则不能操作
  4.     if (scene->player->active != true)return;
  5.     //控制跳跃
  6.     if (GetAsyncKeyState(VK_UP) & 0x8000) {
  7.         if (scene->player->grounded)
  8.             scene->player->velocity.y = 15.0f;
  9.     }
  10.     //控制左右移动
  11.     bool haveMoved = false;
  12.     if (GetAsyncKeyState(VK_LEFT) & 0x8000) {
  13.         scene->player->velocity.x = -5.0f;
  14.         haveMoved = true;
  15.     }
  16.     if (GetAsyncKeyState(VK_RIGHT) & 0x8000) {
  17.         scene->player->velocity.x = 5.0f;
  18.         haveMoved = true;
  19.     }
  20.     //若没有移动，则速度停顿下来
  21.     if (haveMoved != true) {
  22.         scene->player->velocity.x = max(0,scene->player->velocity.x * 0.5f);//使用线性速度的渐进减速
  23.     }
  24. }

所谓的控制移动，其实就是根据输入来给玩家设置x轴和y轴上的速度。

游戏更新

我们知道一个游戏循环内，一般都是先游戏数据更新，然后根据数据显示相应的画面。
所以说游戏更新是一个很重要的内容，由于篇幅有限，本文游戏更新只包含3个内容。

  1. void updateScene(Scene* scene, float dt) {
  2.     //缩小时间尺度为秒单位，1000ms = 1s
  3.     dt /= 1000.0f;
  4.     //更新怪物AI
  5.     updateAI(scene,dt);
  6.     //更新物理和碰撞
  7.     updatePhysics(scene,dt);
  8. }

简单的游戏AI

  1. void updateAI(Scene* scene, float dt) {
  2.     //简单计时器
  3.     static float timeCounter = 0.0f;
  4.     timeCounter += dt;
  5.     //每2秒更改一次方向（随机方向，可能方向不变）
  6.     if (timeCounter >= 2.0f) {
  7.         timeCounter = 0.0f;
  8.         for (int i = 0; i < ENTITYS_NUM; ++i) {
  9.             //存活着的怪物才能被AI操控着移动
  10.             if (scene->eneities[i].active == true && scene->eneities[i].tpye == Enemy) {
  11.                 scene->eneities[i].velocity.x = 3.0f * (1-2*(rand()%2));//(1-2*(rand()%1)要不是 -1要不是1
  12.             }
  13.         }
  14.     }
  15. }

物理模拟&碰撞检测

物理模拟：预测一个物体dt时间后的位置，若该位置碰到其他物体，则说明该物体将会碰到东西
，然后就使该物体位置不变。否则没碰到，就更新物体的新位置。

碰撞检测：实体碰撞这里用的是简单粗暴的，逐个实体比较，若两个实体之间的距离小于1（本文用的是
自己写的distanceSq()函数，返还两点之间的距离的平方，这样运算不需用开方的开销），则断定
该两个实体互相碰撞，然后将他们的索引（在实体数组的第n个位置）交给处理碰撞事件的函数。

  1. //更新物理&碰撞
  2. void updatePhysics(Scene* scene, float dt) {
  3.         //更新实体
  4.         for (int i = 0; i < ENTITYS_NUM; ++i) {
  5.             //若实体死亡，则无需更新
  6.             if (scene->eneities[i].active != true)continue;
  7.             //记录原实体位置
  8.             float x0f = scene->eneities[i].position.x;
  9.             float y0f = scene->eneities[i].position.y;
  10.             int x0 = x0f + 0.5f;
  11.             int y0 = y0f + 0.5f;
  12.             //记录模拟后的实体位置
  13.             float x1f = min(max(scene->eneities[i].position.x + dt * scene->eneities[i].velocity.x, 0.0f), MAP_WIDTH - 1);
  14.             float y1f = min(max(scene->eneities[i].position.y + dt * scene->eneities[i].velocity.y, 1.0f), MAP_HEIGTH - 1);
  15.             int x1 = x1f + 0.5f;
  16.             int y1 = y1f + 0.5f;
  17.             //判断障碍碰撞
  18.             if (scene->barrier[x0][y1] == true) {
  19.                 scene->eneities[i].velocity.y = 0;
  20.                 y1 = y0;
  21.                 y1f = y0f;
  22.             }
  23.             if (scene->barrier[x1][y1] == true) {
  24.                 scene->eneities[i].velocity.x = 0;
  25.                 x1 = x0;
  26.                 x1f = x0f;
  27.             }
  28.             //判断实体碰撞
  29.             for (int j = i + 1; j < ENTITYS_NUM; ++j) {
  30.                 //若实体死亡，则无需判定
  31.                 if (scene->eneities[j].active != true)continue;
  32.                 float disSq = distanceSq(scene->eneities[i].position, scene->eneities[j].position);
  33.                 if (disSq <= 1 * 1) {
  34.                     //若发生碰撞，则处理该碰撞事件
  35.                     handleCollision(scene, i, j, disSq);
  36.                 }
  37.             }
  38.             //判断是否踩到地面（位置的下一格），用于处理跳跃
  39.             if (scene->barrier[x1][max(y1 - 1, 0)] == true) {
  40.                 scene->eneities[i].grounded = true;
  41.             }
  42.             else {
  43.                 scene->eneities[i].velocity.y += dt * scene->gravity;
  44.                 scene->eneities[i].grounded = false;
  45.             }
  47.       //更新实体位置（可能是旧位置也可能是新位置）
  48.             scene->eneities[i].position.x = x1f;
  49.             scene->eneities[i].position.y = y1f;
  50. }

一切看起来很好，但是实际运行的时候发生了物理穿模现象（即物体穿过了模型）。

  • 原因：时间dt*速度的值太大，结果预测位置越过了障碍位置，且预测位置处没有障碍，然后判定这次预测移动成功。
  • 解决方案：将模拟的时间段dt拆分成更小段，从而模拟多次，每次模拟改变的位置值也就减少，减少穿模的可能性。

这是物理引擎的固有缺点，许多游戏都可能发生穿模现象（育碧现象），特别是高速移动的物体。所以常见的手法还有
对高速移动物体进行更多拆分模拟（例如子弹的运动模拟）。

改进后的物理模拟代码,这样我们可以指定stepNum来决定这个dt时间段拆分成多少个小时间段：

  1. //更新物理&碰撞
  2. void updatePhysics(Scene* scene, float dt, int stepNum) {
  3.     dt /= stepNum;
  4.     for (int i = 0; i < stepNum; ++i) {
  5.         //更新实体
  6.         for (int i = 0; i < ENTITYS_NUM; ++i) {
  7.             //若实体死亡，则无需更新
  8.             if (scene->eneities[i].active != true)continue;
  9.             //记录原实体位置
  10.             float x0f = scene->eneities[i].position.x;
  11.             float y0f = scene->eneities[i].position.y;
  12.             int x0 = x0f + 0.5f;
  13.             int y0 = y0f + 0.5f;
  14.             //记录模拟后的实体位置
  15.             float x1f = min(max(scene->eneities[i].position.x + dt * scene->eneities[i].velocity.x, 0.0f), MAP_WIDTH - 1);
  16.             float y1f = min(max(scene->eneities[i].position.y + dt * scene->eneities[i].velocity.y, 1.0f), MAP_HEIGTH - 1);
  17.             int x1 = x1f + 0.5f;
  18.             int y1 = y1f + 0.5f;
  19.             //判断障碍碰撞
  20.             if (scene->barrier[x0][y1] == true) {
  21.                 scene->eneities[i].velocity.y = 0;
  22.                 y1 = y0;
  23.                 y1f = y0f;
  24.             }
  25.             if (scene->barrier[x1][y1] == true) {
  26.                 scene->eneities[i].velocity.x = 0;
  27.                 x1 = x0;
  28.                 x1f = x0f;
  29.             }
  30.             //判断实体碰撞
  31.             for (int j = i + 1; j < ENTITYS_NUM; ++j) {
  32.                 //若实体死亡，则无需判定
  33.                 if (scene->eneities[j].active != true)continue;
  34.                 float disSq = distanceSq(scene->eneities[i].position, scene->eneities[j].position);
  35.                 if (disSq <= 1 * 1) {
  36.                     //若发生碰撞，则处理该碰撞事件
  37.                     handleCollision(scene, i, j, disSq);
  38.                 }
  39.             }
  40.             //判断是否踩到地面
  41.             if (scene->barrier[x1][max(y1 - 1, 0)] == true) {
  42.                 scene->eneities[i].grounded = true;
  43.             }
  44.             else {
  45.                 scene->eneities[i].velocity.y += dt * scene->gravity;
  46.                 scene->eneities[i].grounded = false;
  47.             }
  48.             scene->eneities[i].position.x = x1f;
  49.             scene->eneities[i].position.y = y1f;
  50.         }
  51.     }
  52. }

接下来就是处理碰撞事件了，本文选择模仿超级马里奥的效果：
当玩家和怪物互相碰撞时，若玩家踩到怪物头上，怪物死亡。否则玩家死亡。

  1. //实体死亡函数
  2. void entityDie(Scene* scene,int entityIndex) {
  3.     scene->eneities[entityIndex].active = false;
  4.     scene->eneities[entityIndex].velocity.x = 0;
  5.     scene->eneities[entityIndex].velocity.y = 0;
  6. }
  8. //处理碰撞事件
  9. void handleCollision(Scene* scene, int i,int j,float disSq) {
  10.     //若玩家碰到怪物
  11.     if (scene->eneities[i].tpye == Player && scene->eneities[j].tpye == Enemy) {
  12.         //若玩家高度高于怪物0.3,则证明玩家踩在怪物头上，怪物死亡。
  13.         if (scene->eneities[i].position.y - 0.3f > scene->eneities[j].position.y) {entityDie(scene,j);}
  14.         //否则玩家死亡
  15.         else {entityDie(scene,i);}
  16.     }
  17.     //若怪物碰到玩家
  18.     if (scene->eneities[i].tpye == Enemy  && scene->eneities[j].tpye == Player) {
  19.         //若玩家高度高于怪物0.3,则证明玩家踩在怪物头上，怪物死亡。
  20.         if (scene->eneities[j].position.y - 0.3f > scene->eneities[i].position.y) {entityDie(scene, i);}
  21.         //否则玩家死亡
  22.         else {entityDie(scene, j);}
  23.     }
  24. }

总结

这里已经包含了很多内容，想必大家应该对游戏开发有一些认识了，
然而这个游戏还未能达到真正完整的程度，但是基本的游戏框架已经成型，
要扩展成为一个完整的横板游戏（开始界面，结束条件，奖励，更多敌人/技能等）这些内容就不再
多讲，可以课余尝试自己去实现。

完整源代码（为了方便copy，于是没有分多文件）：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <math.h>
  4. #include <windows.h>
  6. #define MAP_WIDTH 100
  7. #define MAP_HEIGTH 15
  8. #define BUFFER_WIDTH 50
  9. #define BUFFER_HEIGTH 15
  10. #define ENTITYS_NUM 11
  12. struct ViewBuffer {
  13.     char buffer[BUFFER_WIDTH][BUFFER_HEIGTH];
  14.     HANDLE hOutBuf[2];//控制台屏幕缓冲区句柄
  15. };
  17. struct Vec2 {
  18.     float x;
  19.     float y;
  20. };
  22. float distanceSq(Vec2 a1, Vec2 a2) {
  23.     float dx = a1.x - a2.x;
  24.     float dy = a1.y - a2.y;
  25.     return dx * dx + dy * dy;
  26. }
  28. enum EntityTpye {
  29.     Player, Enemy
  30. };
  32. struct Entity {
  33.     Vec2 position;
  34.     Vec2 velocity;
  35.     EntityTpye tpye;
  36.     char texture;
  37.     bool grounded;
  38.     bool active;
  39. };
  41. struct Scene {
  42.     Entity eneities[ENTITYS_NUM + 10];
  43.     bool barrier[MAP_WIDTH][MAP_HEIGTH];
  44.     Entity* player;
  45.     float gravity;
  46. };
  48. void initViewBuffer(ViewBuffer * vb) {
  49.     for (int i = 0; i < BUFFER_WIDTH; ++i)
  50.     for (int j = 0; j < BUFFER_HEIGTH; ++j)
  51.             vb->buffer[i][j] = ' ';
  52.     //创建新的控制台缓冲区
  53.     vb->hOutBuf[0] = CreateConsoleScreenBuffer(
  54.         GENERIC_WRITE,//定义进程可以往缓冲区写数据
  55.         FILE_SHARE_WRITE,//定义缓冲区可共享写权限
  56.         NULL,
  57.         CONSOLE_TEXTMODE_BUFFER,
  58.         NULL
  59.     );
  60.     vb->hOutBuf[1] = CreateConsoleScreenBuffer(
  61.         GENERIC_WRITE,//定义进程可以往缓冲区写数据
  62.         FILE_SHARE_WRITE,//定义缓冲区可共享写权限
  63.         NULL,
  64.         CONSOLE_TEXTMODE_BUFFER,
  65.         NULL
  66.     );
  67.     //隐藏两个缓冲区的光标
  68.     CONSOLE_CURSOR_INFO cci;
  69.     cci.bVisible = 0;
  70.     cci.dwSize = 1;
  71.     SetConsoleCursorInfo(vb->hOutBuf[0], &cci);
  72.     SetConsoleCursorInfo(vb->hOutBuf[1], &cci);
  73.  }
  75. void updateViewBuffer(Scene* scene, ViewBuffer * vb) {
  76.     //更新BUFFER中的地面+障碍物
  77.     int playerX = scene->player->position.x + 0.5f;
  78.     int offsetX = min(max(0, playerX - BUFFER_WIDTH / 2), MAP_WIDTH - BUFFER_WIDTH-1);
  79.     for (int i = 0; i < BUFFER_WIDTH; ++i)
  80.         for (int j = 0; j < BUFFER_HEIGTH; ++j)
  81.         {
  82.             if (scene->barrier[i + offsetX][j] == false)
  83.                 vb->buffer[i][j] = ' ';
  84.             else
  85.                 vb->buffer[i][j] = '=';
  86.         }
  87.     //更新BUFFER中的实体
  88.     for (int i = 0; i < ENTITYS_NUM; ++i) {
  89.         int x = scene->eneities[i].position.x + 0.5f;
  90.         int y = scene->eneities[i].position.y + 0.5f;
  91.         if (scene->eneities[i].active == true && offsetX <= x && x < MAP_WIDTH) {
  92.             vb->buffer[x - offsetX][y] = scene->eneities[i].texture;
  93.         }
  94.     }
  95. }
  97. void drawViewBuffer(Scene* scene ,ViewBuffer * vb) {
  98.     //先根据场景数据，更新相应的缓冲区数据
  99.     updateViewBuffer(scene,vb);
  101.     static int buffer_index = 0;
  102.     COORD coord = { 0,0 };
  103.     DWORD bytes = 0;
  104.     for (int i = 0; i < BUFFER_WIDTH; ++i)
  105.     for (int j = 0; j < BUFFER_HEIGTH; ++j)
  106.     {
  107.         coord.X = i;
  108.         coord.Y = BUFFER_HEIGTH - 1 - j;
  109.         WriteConsoleOutputCharacterA(vb->hOutBuf[buffer_index], &vb->buffer[i][j],1, coord, &bytes);
  110.     }
  111.     //设置新的缓冲区为活动显示缓冲区
  112.     SetConsoleActiveScreenBuffer(vb->hOutBuf[buffer_index]);
  113.     buffer_index = !buffer_index;
  114. }
  116. void initScene(Scene* scene){
  117.     //障碍初始化
  118.     bool(*barr)[15] = scene->barrier;
  119.     //所有地方初始化为无障碍
  120.     for (int i = 0; i < MAP_WIDTH; ++i)
  121.         for (int j = 0; j < MAP_HEIGTH; ++j)
  122.             barr[i][j] = false;
  123.     //地面也是一种障碍，高度为0
  124.     for (int i = 0; i < MAP_WIDTH; ++i)
  125.         barr[i][0] = true;
  126.     //自定义障碍
  127.     barr[4][1] = barr[4][2] = barr[4][3] = barr[5][1] = barr[5][2]= barr[6][1]
  128.     = barr[51][3] = barr[52][3] = barr[53][3] = barr[54][3] = barr[55][3] = barr[56][3]= barr[57][3]
  129.     = true;
  131.     //敌人初始化
  132.     for (int i = 0; i < ENTITYS_NUM-1; ++i) {
  133.         scene->eneities[i].position.x = 5.0f + rand()%(MAP_WIDTH-5);
  134.         scene->eneities[i].position.y = 10;
  135.         scene->eneities[i].velocity.x = 0;
  136.         scene->eneities[i].velocity.y = 0;
  137.         scene->eneities[i].texture = '#';
  138.         scene->eneities[i].tpye = Enemy;
  139.         scene->eneities[i].grounded = false;
  140.         scene->eneities[i].active = true;
  141.     }
  142.     //玩家初始化
  143.     scene->player = &scene->eneities[ENTITYS_NUM-1];
  144.     scene->player->position.x = 0;
  145.     scene->player->position.y = 15;
  146.     scene->player->velocity.x = 0;
  147.     scene->player->velocity.y = 0;
  148.     scene->player->texture = '@';
  149.     scene->player->tpye = Player;
  150.     scene->player->active = true;
  151.     scene->player->grounded = false;
  152.     //设置重力
  153.     scene->gravity = -29.8f;
  154. }
  156. //某个实体死亡
  157. void entityDie(Scene* scene,int entityIndex) {
  158.     scene->eneities[entityIndex].active = false;
  159.     scene->eneities[entityIndex].velocity.x = 0;
  160.     scene->eneities[entityIndex].velocity.y = 0;
  161. }
  163. //处理碰撞事件
  164. void handleCollision(Scene* scene, int i,int j,float disSq) {
  165.     //若玩家碰到怪物
  166.     if (scene->eneities[i].tpye == Player && scene->eneities[j].tpye == Enemy) {
  167.         //若玩家高度高于怪物0.3,则证明玩家踩在怪物头上，怪物死亡。
  168.         if (scene->eneities[i].position.y - 0.3f > scene->eneities[j].position.y) {entityDie(scene,j);}
  169.         //否则玩家死亡
  170.         else {entityDie(scene,i);}
  171.     }
  172.     //若怪物碰到玩家
  173.     if (scene->eneities[i].tpye == Enemy  && scene->eneities[j].tpye == Player) {
  174.         //若玩家高度高于怪物0.3,则证明玩家踩在怪物头上，怪物死亡。
  175.         if (scene->eneities[j].position.y - 0.3f > scene->eneities[i].position.y) {entityDie(scene, i);}
  176.         //否则玩家死亡
  177.         else {entityDie(scene, j);}
  178.     }
  179. }
  181. //更新物理&碰撞
  182. void updatePhysics(Scene* scene, float dt, int stepNum) {
  183.     dt /= stepNum;
  184.     for (int i = 0; i < stepNum; ++i) {
  185.         //更新实体
  186.         for (int i = 0; i < ENTITYS_NUM; ++i) {
  187.             //若实体死亡，则无需更新
  188.             if (scene->eneities[i].active != true)continue;
  189.             //记录原实体位置
  190.             float x0f = scene->eneities[i].position.x;
  191.             float y0f = scene->eneities[i].position.y;
  192.             int x0 = x0f + 0.5f;
  193.             int y0 = y0f + 0.5f;
  194.             //记录模拟后的实体位置
  195.             float x1f = min(max(scene->eneities[i].position.x + dt * scene->eneities[i].velocity.x, 0.0f), MAP_WIDTH - 1);
  196.             float y1f = min(max(scene->eneities[i].position.y + dt * scene->eneities[i].velocity.y, 1.0f), MAP_HEIGTH - 1);
  197.             int x1 = x1f + 0.5f;
  198.             int y1 = y1f + 0.5f;
  199.             //判断障碍碰撞
  200.             if (scene->barrier[x0][y1] == true) {
  201.                 scene->eneities[i].velocity.y = 0;
  202.                 y1 = y0;
  203.                 y1f = y0f;
  204.             }
  205.             if (scene->barrier[x1][y1] == true) {
  206.                 scene->eneities[i].velocity.x = 0;
  207.                 x1 = x0;
  208.                 x1f = x0f;
  209.             }
  210.             //判断实体碰撞
  211.             for (int j = i + 1; j < ENTITYS_NUM; ++j) {
  212.                 //若实体死亡，则无需判定
  213.                 if (scene->eneities[j].active != true)continue;
  214.                 float disSq = distanceSq(scene->eneities[i].position, scene->eneities[j].position);
  215.                 if (disSq <= 1 * 1) {
  216.                     //若发生碰撞，则处理该碰撞事件
  217.                     handleCollision(scene, i, j, disSq);
  218.                 }
  219.             }
  220.             //判断是否踩到地面
  221.             if (scene->barrier[x1][max(y1 - 1, 0)] == true) {
  222.                 scene->eneities[i].grounded = true;
  223.             }
  224.             else {
  225.                 scene->eneities[i].velocity.y += dt * scene->gravity;
  226.                 scene->eneities[i].grounded = false;
  227.             }
  228.             scene->eneities[i].position.x = x1f;
  229.             scene->eneities[i].position.y = y1f;
  230.         }
  231.     }
  232. }
  234. //怪物AI更新
  235. void updateAI(Scene* scene, float dt) {
  236.     //简单计时器
  237.     static float timeCounter = 0.0f;
  238.     timeCounter += dt;
  239.     //每2秒更改一次方向（随机方向，可能方向不变）
  240.     if (timeCounter >= 2.0f) {
  241.         timeCounter = 0.0f;
  242.         for (int i = 0; i < ENTITYS_NUM; ++i) {
  243.             //存活着的怪物才能被AI操控着移动
  244.             if (scene->eneities[i].active == true && scene->eneities[i].tpye == Enemy) {
  245.                 scene->eneities[i].velocity.x = 3.0f * (1-2*(rand()%2));//(1-2*(rand()%1)要不是 -1要不是1
  246.             }
  247.         }
  248.     }
  249. }
  251. //场景更新
  252. void updateScene(Scene* scene, float dt) {
  253.     //缩小时间尺度
  254.     dt /= 1000.0f;
  255.     //更新怪物AI
  256.     updateAI(scene,dt);
  257.     //更新物理和碰撞，拆分成5次模拟
  258.     updatePhysics(scene,dt,5);
  259. }
  261. //处理输入
  262. void handleInput(Scene* scene) {
  263.     //如果玩家死亡，则不能操作
  264.     if (scene->player->active != true)return;
  265.     //控制跳跃
  266.     if (GetAsyncKeyState(VK_UP) & 0x8000) {
  267.         if (scene->player->grounded)
  268.             scene->player->velocity.y = 15.0f;
  269.     }
  270.     //控制左右移动
  271.     bool haveMoved = false;
  272.     if (GetAsyncKeyState(VK_LEFT) & 0x8000) {
  273.         scene->player->velocity.x = -5.0f;
  274.         haveMoved = true;
  275.     }
  276.     if (GetAsyncKeyState(VK_RIGHT) & 0x8000) {
  277.         scene->player->velocity.x = 5.0f;
  278.         haveMoved = true;
  279.     }
  280.     //若没有移动，则速度停顿下来
  281.     if (haveMoved != true) {
  282.         scene->player->velocity.x = max(0,scene->player->velocity.x * 0.5f);//使用线性速度的渐进减速
  283.     }
  284. }
  286. int main() {
  287.     double TimePerFrame = 100.0f;
  289.     ViewBuffer viewBuffer;
  290.     initViewBuffer(&viewBuffer);
  292.     Scene scene;
  293.     initScene(&scene);
  295.     //记录上一帧的时间点
  296.     DWORD lastTime;
  297.     lastTime = GetTickCount();
  299.     while (1) {
  300.         DWORD nowTime = GetTickCount();         //获得当前帧的时间点
  301.         DWORD deltaTime = nowTime - lastTime;   //计算这一帧与上一帧的时间差
  302.         lastTime = nowTime;                     //更新上一帧的时间点
  304.         handleInput(&scene);//处理输入
  305.         updateScene(&scene,deltaTime);//运算（场景数据模拟）
  306.         drawViewBuffer(&scene,&viewBuffer);//渲染（显示场景画面）
  308.         //若 实际时间差 少于 每帧固定时间差，则让机器休眠 少于的部分时间。
  309.         if (deltaTime <= TimePerFrame)
  310.             Sleep(TimePerFrame - deltaTime);
  311.     };
  313.     return 0;
  314. }
 友情链接：直通硅谷 　点职佳 　北美留学生论坛

游戏设计热门文章

  • DirectX11--深入理解与使用2D纹理资源
  • unity渲染篇：烘焙模型贴图
  • Unity导入模型出现 (Avatar Rig Configuration mis-match. Bone length in configuration does not match position in animation)?
  • Unreal: Dynamic load map from Pak file
  • 《unity 3D 游戏开发 第二版》宣雨松 分享 pdf下载
  • 空间划分的数据结构(网格/四叉树/八叉树/BSP树/k-d树/BVH/自定义划分)
  • Unity编辑器汉化(中文语言包)
  • [Unity编辑器扩展基础总结] 第3章 编辑器下的数据保存
  • Unity 3D游戏开发 pdf高清下载
  • 用C#写一个俄罗斯方块

    • 游戏设计推荐文章

  • Unity3D开发入门教程（二）—— Lua入门
  • Unity3D开发入门教程（三）——添加启动脚本
  • Unity3D开发入门教程（四）——用Lua实现组件
  • RectMask2D裁剪Canvas无效问题
  • Python编程环境设置
  • Minecraft类游戏地形生成机制
  • 3D网页小实验-基于Babylon.js与recast.js实现RTS式单位控制
  • Unity3D OpenVR 虚拟现实 保龄球打砖块游戏开发
  • [Unity编辑器扩展基础总结] 第3章 编辑器下的数据保存
  • 关于看门狗的两种模型以及带来的思考

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号