手把手教你编写游戏模拟器 - Chip8篇

手把手教你编写游戏模拟器 - Chip8篇

翻译整理分析：by Yiran Xie

*如要转载请附上本文链接

 

最近在学习游戏模拟器的编写，发现国内现成的教程少之又少，代码倒是能找到不少，不过缺乏系统的讲解看起来颇为费时费力（谁让咱是菜鸟一个呢)。于是打算一边学习，一边把搜集的资料和开发的心得整理后，陆续发布一系列关于模拟器编写的教程，本文主要讲解Chip8模拟器的编写，第二步是会发布关于编写NES（也叫FC/红白机/小霸王）模拟器编写的教程。

 

本文作为开篇，可能算是最容易的模拟器了，英文原文来自这里。我在翻译的同时添加了个人的理解作为补充，最后会分析下源代码。

 

 

 

引子

Chip 8可能是所有模拟器中最容易上手的了，其中最主要的原因就是它架构比较简单。不过麻雀虽小五脏俱全，通过这样一个例子可以很好地了解模拟器的架构，为之后更复杂的模拟器编写做个铺垫。

 

 

 

什么是模拟器

模拟器是对于某个系统A的架构与功能的模拟，使得为系统A编写的软件可以运行在架构完全不一样的系统B上。比如原本NES游戏机（小霸王）上的游戏，现在可以通过模拟运行在PC、手持设备上等等。

 

 

 

什么是CHIP-8?

Chip8其实并不是个真正的系统，它更像是一个虚拟机(virtual machine)，用Chip8语言编写的游戏可以很容易地在任何装有Chip8解释器的系统中运行。它是70年代由Joseph Weisbecker所开发。

 

 

 

为什么选择CHIP-8?

Chip8模拟器可能是你能发现的最容易编写的模拟器了。它仅有35个opcode(cpu指令),其中大多数都是基本的功能，在更先进的CPU架构中依然能找到。因此这样一个项目是非常具有学习价值的，可以帮你获悉CPU是如何运作的以及机器代码是如何被执行的。同时，因为它opcode数量小，所以更易管理，整个学习的曲线也更短。

 

 

 

在开始之前…

·  选择一门你拿手的编程语言 (常见的有C/C++ 或 Java).
以下代码主要用的是 C/C++

·  这个项目不易作为学习编程的项目
(如果对位操作（与，或，移位，异或等）不熟悉的话，不妨先搜点教程看看)

·  你可能会用到第三方的库来实现音频、视频的输出以及用户的输入，比如 GLUT / SDL / DirectX

·  OK GO!

 

 

了解CPU 

当开始编写模拟器之前，你需要尽可能多地查找你要模拟平台上的CPU的信息。比如，它使用的内存以及寄存器的数量、大小，它用的是什么架构，要是能找到技术文档就更好了。

对于我们这里要做的Chip 8, 我建议可以参考Wiki上的Chip 8 description（推荐）。

这里先来总体介绍下Chip8的系统。

·  Chip 8 有35个opcodes（cpu指令），其中每个都是双字节长(2 bytes)。因此为了储存它，我们需要一种数据类型能让我们存储双字节，这里选用unsigned short：

unsigned short opcode;

·  Chip 8共有4K内存，我们可以这么表示：

unsigned char memory[4096];

·  CPU 寄存器：Chip 8 有16个单字节(1 byte)寄存器，名字为V0,V1...到VF. 前15个寄存器为通用寄存器，最后一个寄存器(VF)是个进位标志(carry flag).这16个寄存器表示为：

unsigned char V[16];

·  索引寄存器I（原文为Index register，不知道更专业的应该怎么翻译，这里暂译为“索引寄存器”）与 程序计数器（pc - program counter），值域为0x000 到 0xFFF：

unsigned short I; unsigned short pc;

· 内存映像图(memory map) - 对应着上面的memory[4096]:

0x000-0x1FF - Chip 8解释器(包含用于显示的字体) 0x050-0x0A0 - 用于生成 4x5 像素的字体集合 (从’0’到’F’) 0x200-0xFFF - 游戏ROM 与工作RAM

·  图像系统：Chip 8包含一条指令用于把小图案（Sprite,国内也有直译叫’精灵’的）画到屏幕上. 这个绘画的过程用的是XOR(异或)的操作，如果一个像素经过绘画操作后被设为0(不显示)，则VF寄存器被相应地更新。

·  Chip 8的显示是二值化的，总共有2048个像素 (64 x 32)，每个像素有两种状态1或0（常见0表示黑，1表示白）。选用下面这种存储结构：

unsigned char gfx[64 * 32];

·  Chip 8没有中断以及硬件寄存器（hardware register，不知道怎么翻译），不过有两个timer（计时器），当它们被设定为一个正值时候，他们应当以opcode的执行频率倒计时直至0为止。（即每执行一条opcode后，如果当前两个timer为正，应当对其进行--操作。opcode的理想情况是被运行在60hz，这个是需要你去想办法保证的）

unsigned char delay_timer; unsigned char sound_timer;

·  在原系统中，当sound_timer寄存器倒计时到0时，系统会发出蜂鸣声。（这里作者写的模拟器是没有声音系统的。不过只是缺少蜂鸣声也无所谓吧）

有一点很重要，Chip 8的指令集包含了跳转（相当于jmp/goto，不用返回）或者调用子函数（相当于call，需要返回）。虽然CPU参数中并未提及栈(stack),但是你需要自己去实现一个。栈在这里被用于在调用子函数之前保存当前的pc(程序计数器)的位置，所以在任何时候你打算调用其他子函数，你需要在执行之前把当前的程序计数器push进栈。 这个系统用的栈有16层，同时你需要一个栈顶指针(stack pointer - sp)去指向当前的栈顶。

unsigned short stack[16]; unsigned short sp;

最后, Chip 8的输入是一个16个按键的键盘(0x0-0xF), 你可以用一个数组来存储当前按键的状态：

unsigned char key[16];

 

 

 

游戏主程序

为了提供一个更直观的感觉， 这里把游戏的的主程序做一下概述。这里不会提及如何用GLUT或者SDL去实现图像或者输入系统，而仅仅是展示整个模拟器的运作过程。

#include //OpenGL以及输入系统的库文件

#include "chip8.h" //关于cpu核心运作的实现，一会儿会讲到

 chip8 myChip8;//这里模拟器的实体mychip8被定义为全局变量 int main(int argc, char **argv) { setupGraphics();//初始化图像(窗口大小, 显示模式等等)

  setupInput();//初始化输入系统 //初始化Chip8 系统以及把游戏rom加载到内存

  myChip8.initialize();//清理内存、寄存器、屏幕

  myChip8.loadGame("pong");//加载rom，“pong”是个乒乓球游戏 //模拟的主循环

  for(;;) { 　　myChip8.emulateCycle();// 模拟一个指令周期

 

　　/*由于系统不是每个周期都需要执行绘画操作，因此设立一个是否需要画图的标志位。当需要修改时把它置为1，不需要时则为0 　　只有两种cpu指令(Opcode)需要设置这个标志位为1： 　　0x00E0 – 清理屏幕 　　0xDXYN – 把图案画到屏幕上*/

    if(myChip8.drawFlag) drawGraphics(); myChip8.setKeys();// 保存按键信息（按下与释放）

 } return 0; }

 

 

 

模拟器的主循环

下面更仔细地来看看这个模拟的主循环。

void chip8::initialize() { //初始化内存与寄存器（注意这个操作一共只执行一次）

} void chip8::emulateCycle()//这个操作每个模拟周期都会执行一次

{ //获取opcode //解码opcode //执行opcode //更新计时器

}

获取opcode
在这一步中, 系统会从PC(程序计数器)所指的值中取出opcode。 前面已经提到，每个opcode是双字节的，不过模拟器的内存是设置成单字节的数组（unsigned char memory[4096]），因此我们需要一次读取连续两个字节的内容，然后把它拼接在一起去形成一个完整的opcode。

为了展示它是怎么运作的，我们这里选用opcode 0xA2F0.

// 假设如下情况

memory[pc]     == 0xA2 memory[pc + 1] == 0xF0

为了把两个字节合并在一起，我们用如下操作:

opcode = memory[pc] << 8 | memory[pc + 1];

即先把0xA2左移8位，这将在尾部增加8个0.

0xA2       0xA2 << 8 = 0xA200 //16进制 10100010   1010001000000000     //2进制

接着我们使用’|’运算符去合并:

1010001000000000 | //0xA200

        11110000 = //0xF0 (0x00F0)

------------------

1010001011110000   //0xA2F0

 

解码opcode
我们现在已经存储了当前的opcode，接着我们要去解码它，看看这条opcode究竟有什么作用。这里依然以0xA2F0为例。

经过查表 我们可以得知:

·  ANNN: Sets I to the address NNN

即把NNN这个内存地址赋给索引寄存器I（NNN 相当于掩码，指代opcode的后3位，即0x2F0，或者可以理解为A为操作指令，NNN对应着操作数)。

 

执行opcode
现在我们已经明确了我们要对opcode执行什么操作，因此我们可以在模拟器中模拟这个操作. 比如还是 0xA2F0这条指令，我们现在把0x2F0赋给索引寄存器I。一个细节是0XA2F0是16位的，我们要从中取出低12位的0x2F0，这里用'&'操作实现:

1010001011110000 & // 0xA2F0 (opcode)

0000111111111111 = // 0x0FFF

------------------

0000001011110000   // 0x02F0 (0x2F0)

最终的代码:

I = opcode & 0x0FFF; pc += 2;

因为每条指令都是双字节长，所以我们需要把程序计数器的步进长度设为2，即一次前进2个字节。这个针对的是大多数的情况。不过如果这条opcode是跳转，则需要更改PC；而调用子函数之前，则还需要把PC存入栈。如果下一条opcode需要被跳过(有些opcode的作用为“当满足xxx情况时，跳过下条指令”)，此时程序计数器一次前进4.

 

计时器
除了执行opcode以外，Chip 8 还有两个计时器需要去实现。就像前面提及的，两个计时器（delay timer和sound timer），当它们被设置为一个正数的时候，都会倒计时到0。 由于这些计时器在理想情况下（在原系统上）应当以60hz的速度倒计时，因此你需要想一些办法去减缓你的模拟周期（如果不进行控制，现代CPU全速运行会导致帧数过快），使得一秒钟刚好能执行60条opcodes。

 

 

 

更进一步

现在你已经知道了模拟的基本过程以及整个系统是怎么运作的。那么现在就把这些部分合并在一起吧并且开始编写这个模拟器。

 

初始化系统
在执行第一个模拟周期之前，你需要做一些准备工作：初始化内存以及寄存器。虽然Chip8没有BIOS或系统固件，它却有一个基本的字体集（数字和字母的显示字体集合）存在内存中。字体集的大小为0x50，应当被存入到内存中0x00-0x50（80）的地方。

另一个需要注意的是ROM（相当于代码段）应当被加载到0x200的地方，同时也意味着pc最初也应该指向这里。

void chip8::initialize() { pc = 0x200;  //程序计数器指向 0x200

  opcode = 0;      //初始化“当前opcode” 

  I      = 0;      //初始化索引寄存器

  sp     = 0;      //初始化栈顶指针 //清理显存 //清理栈 //清理从V0到VF的寄存器 //清理内存 // 读取字体集

  for(int i = 0; i < 80; ++i) memory[i] = chip8_fontset[i]; //初始化计时器

}

 

把程序(游戏ROM)读入内存
在初始化之后，把程序读入内存(用fopen以二进制方式打开)并且把内容依次读取到0x200（512）开始的内存中：

for(int i = 0; i < bufferSize; ++i) memory[i + 512] = buffer[i];

 

开始模拟
现在我们的系统已经准备好去执行它的第一条指令。就像之前提到的，我们需要按照获取/解码/执行的步骤执行opcode。在这个例子中，我们首先读取opcode的前4位，然后看看这个opcode的作用：

void chip8::emulateCycle() { //获取opcode

  opcode = memory[pc] << 8 | memory[pc + 1]; //解码opcode（这里先读取高4位用于判断）

  switch(opcode & 0xF000) { //...其他opcodes 


    case 0xA000: //ANNN:把NNN赋给索引寄存器I //执行opcode

      I = opcode & 0x0FFF; pc += 2; break; //...其他opcodes 

    default: printf ("Unknown opcode: 0x%X\n", opcode); } //更新timers（opcode与timer频率相同）

  if(delay_timer > 0) -- delay_timer; if(sound_timer > 0) { if(sound_timer == 1) printf("BEEP!\n");//第一看，被雷到了-.- -- sound_timer; } }

不过在一些情况下，我们不能仅凭借前4位去判断这条opcode的作用。比如0x00E0和0x00EE的前4位都是0。在这种情况下，我们需要进一步去判断其低4位。

//解码opcode

switch(opcode & 0xF000)//这是判断高4位 { case 0x0000://当高4位都是0x0时，需要进一步判断低4位 switch(opcode & 0x000F)//进一步判断低4位  { case 0x0000: // 0x00E0:清理屏幕 //执行“清理屏幕” break; case 0x000E: // 0x00EE:从子函数返回 //执行“从子函数返回” break; default: printf ("Unknown opcode [0x0000]: 0x%X\n", opcode); } break; //更多的opcodes // }

 

Opcode中一些需要注意的个例

例1: Opcode 0x2NNN
这条opcode调用位于NNN地址的子函数，在跳转之前我们把当前PC中的地址进行保存，以便子函数结束后能够返回。在储存完毕之后，栈顶指针应当指向下一个空位（注意，这个栈是向上生长的，所以是++）。接着，把PC设为新的地址（通过与0x0FFF进行与操作取得“NNN”对应的地址）。注意，因为我们执行了跳转，所以这里没有必要再把PC + 2了。

case 0x2000: stack[sp] = pc; ++ sp; pc = opcode & 0x0FFF; break;

例2: Opcode 0x8XY4
这条指令把寄存器VY累加到VX上。如果加法过程中出现了溢出，则要把寄存器VF（前面提到的16个寄存器中的最后一个，进位寄存器）相应置为1，如果没有溢出，则置为0。因为寄存器是单字节的，仅能存储0~255，当VX与VY之和大于255时，它就不能被完整地存于寄存器中（事实上超出255的部分会从0重新开始累加），所以我们用VF这个寄存器来告知系统VX，VY之和实际上>255。 别忘了执行的最后要把PC + 2.

case 0x0004: 

  if(V[(opcode & 0x00F0) >> 4] > (0xFF - V[(opcode & 0x0F00) >> 8]))//即VY > 255 - VX V[0xF] = 1;//出现了溢出，则把VF置为1

  else V[0xF] = 0;//没有溢出VF置为0

  V[(opcode & 0x0F00) >> 8] += V[(opcode & 0x00F0) >> 4];//VX += VY

  pc += 2; break;

例3: Opcode 0xFX33
作用：把VX的十进制的表示存于I/I+1/I+2三个地址。其中I存百位，I+1存十位，I+2存个位。

case 0x0033:

  memory[I]     = V[(opcode & 0x0F00) >> 8] / 100;//取得十进制百位

  memory[I + 1] = (V[(opcode & 0x0F00) >> 8] / 10) % 10;//取得十进制十位

  memory[I + 2] = (V[(opcode & 0x0F00) >> 8] % 100) % 10;//取得十进制个位

  pc += 2; break;

 

 

 

处理图像与输入

像素的绘制
负责处理图像输出的opcode是0xDXYN。Wikipedia中给我们提供了如下的信息：

·  在(VX, VY)坐标处画一个像素宽度固定为8，像素高度为N的小图案。这个图案在内存中的起始地址位于I（索引寄存器的值），每个字节的8位刚好表示8个像素（1个像素对应1位），比如I中保存着图案第一行的8个像素，I+1保存着图案第二行的8个像素，以此类推。执行此opcode，并不会改变I的值。当发生"碰撞"时，VF置为1，否则为0.

就像上面告诉我们的一样，Chip 8 实际上通过画小图案来更新屏幕显示。它告诉了我们这个图案需要被画到的位置（opcode中告诉了我们当前是哪些寄存器存储着横纵坐标。“DXYN”中，XY为保存着横纵坐标的寄存器，N为高度，宽度则是恒定的8个像素）。

异或操作：

01000101 ^

11110011 =

----------

10110110

假设当前的opcode为0xD003，则说明想在(V[0], V[0])处画一个宽为8，高为3的图案。在内存的I处：

memory[I]     = 0x3C; memory[I + 1] = 0xC3; memory[I + 2] = 0xFF;//这些值只是个例子

以上这3个字节是如何表达一个图案的？看看他们的二进制表示吧，这样更直观：

16进制 2进制 图案 0x3C   00111100     ****

0xC3   11000011   **    **

0xFF   11111111   ********

是不是很有趣呢？不过，在通过异或来设置gfx[]之前，如果某像素p当前处于显示的状态（即显示缓存gfx[p]为1)，同时这次绘画依然希望它为1（I[]中对应也为1），则称为发生了“碰撞”，此时把VF置为1.

opcode 0xDXYN的范例：

//绘画指令

case 0xD000: { unsigned short x = V[(opcode & 0x0F00) >> 8]; unsigned short y = V[(opcode & 0x00F0) >> 4];//取得x,y(横纵坐标)

  unsigned short height = opcode & 0x000F;//取得图案的高度

  unsigned short pixel; V[0xF] = 0;//初始化VF为0

  for(int yline = 0; yline < height; yline++)//对于每一行

 { pixel = memory[I + yline];//取得内存I处的值，pixel中包含了一行的8个像素

    for(int xline = 0; xline < 8; xline++)//对于一行的8个像素

 { if((pixel & (0x80 >> xline)) != 0)//检查每个像素是否为1

 { if(gfx[(x + xline + ((y + yline) * 64))] == 1)//如果显示缓存gfx[]里该像素也为1，则发生了碰撞(64是CHIP8的显示宽度)

          V[0xF] = 1;//设置VF为1 

        gfx[x + xline + ((y + yline) * 64)] ^= 1;//gfx中用1个byte来表示1个像素，其值为0或1。这个异或相当于取反

 } } } drawFlag = true;//绘画标志位置为1

  pc += 2; } break;

 

输入
Chip 8系统用了16个按键的键盘来接受输入。对于我们的模拟器来说，需要实现一个方法用于记录所有键的状态。在每次的执行周期中，都需要查看按键的状态，并且把它更新到key[].当按键被按下后，我们把key[]中对应位置为1，当按键被释放（抬起）后，把它置为0。opcode 0xEX9E和0xEXA1会去检查某个指定的按键是否被按下或释放，opcode 0xFX0A会等待一个按键被按下，一旦当它接收到，它会把被按下的按键的序号而不是按键的状态存入寄存器。

case 0xE000: switch(opcode & 0x00FF) { // EX9E: 如果VX（X就是EX9E中的X）中保存的按键此时被按下，则跳过下条指令

    case 0x009E: if(key[V[(opcode & 0x0F00) >> 8]] != 0) pc += 4; else pc += 2; break;

下图左边是原始键盘的按键分布。事实上怎么映射按键可以随你个人兴趣，不过建议你设置成下图右边的方式。

 Keypad Keyboard +-+-+-+-+                +-+-+-+-+

|1|2|3|C|                |1|2|3|4|

+-+-+-+-+                +-+-+-+-+

|4|5|6|D|                |Q|W|E|R|

+-+-+-+-+       =>       +-+-+-+-+

|7|8|9|E|                |A|S|D|F|

+-+-+-+-+                +-+-+-+-+

|A|0|B|F|                |Z|X|C|V|

+-+-+-+-+                +-+-+-+-+

 

 

 

CHIP-8字体集

这是Chip 8的字体集。每个字符用一个像素矩阵来表示，4像素宽，5像素高。

unsigned char chip8_fontset[80] = { 0xF0, 0x90, 0x90, 0x90, 0xF0, // 0

  0x20, 0x60, 0x20, 0x20, 0x70, // 1

  0xF0, 0x10, 0xF0, 0x80, 0xF0, // 2

  0xF0, 0x10, 0xF0, 0x10, 0xF0, // 3

  0x90, 0x90, 0xF0, 0x10, 0x10, // 4

  0xF0, 0x80, 0xF0, 0x10, 0xF0, // 5

  0xF0, 0x80, 0xF0, 0x90, 0xF0, // 6

  0xF0, 0x10, 0x20, 0x40, 0x40, // 7

  0xF0, 0x90, 0xF0, 0x90, 0xF0, // 8

  0xF0, 0x90, 0xF0, 0x10, 0xF0, // 9

  0xF0, 0x90, 0xF0, 0x90, 0x90, // A

  0xE0, 0x90, 0xE0, 0x90, 0xE0, // B

  0xF0, 0x80, 0x80, 0x80, 0xF0, // C

  0xE0, 0x90, 0x90, 0x90, 0xE0, // D

  0xF0, 0x80, 0xF0, 0x80, 0xF0, // E

  0xF0, 0x80, 0xF0, 0x80, 0x80  // F

};

上面看起来有点杂乱无章，不过来看看其二进制表示：

10进制 16进制 2进制 数字0 10进制 16进制 2进制 数字7 240   0xF0   1111 0000    ****     240   0xF0   1111 0000    ****

144   0x90   1001 0000    *  *      16   0x10   0001 0000       *

144   0x90   1001 0000    *  *      32   0x20   0010 0000      *

144   0x90   1001 0000    *  *      64   0x40   0100 0000     *

240   0xF0   1111 0000    ****      64   0x40   0100 0000     *

 

 

结语

 

希望这个教程能为你自己DIY模拟器提供足够多的信息。至少你应该有了一个模拟器如何运作以及CPU如何执行指令的基本的概念。

 

作者在最后提供了三个版本的源代码，一个新版本，一个旧版本，一个Android的版本。这里主要讨论下其新版的代码，其余版本可以在作者主页末尾处找到。

 

 

 

 

具体的源码分析请见 第二篇