C++版 Chip8游戏模拟器

很早就想写个FC模拟器，但真是一件艰难的事情。。

所以先写个Chip8模拟器，日后再继续研究FC模拟器。

Chip8只有35条指令，属于RISC指令集，4k内存，2k显存，16个寄存器（其中15个通用寄存器），支持16个按键，没有中断，但是有两个计时器。

读了下面两个链接，就完全能理解了。

http://www.cnblogs.com/YiranXie/category/539179.html

http://en.wikipedia.org/wiki/CHIP-8

把代码贴一下吧。

 #ifndef __CHIP8_H__
 #define __CHIP8_H__

 class Chip8
 {
 public:
     bool drawFlag;
     void emulateCycle();
     bool loadApplication(const char* fileName);
     unsigned char gfx[ * ];
     unsigned char key[];

 private:
     //35条opcode写成函数，为了效率，使用inline
     inline void op_0NNN();
     inline void op_00E0();
     inline void op_00EE();
     inline void op_1NNN();
     inline void op_2NNN();
     inline void op_3XNN();
     inline void op_4XNN();
     inline void op_5XY0();
     inline void op_6XNN();
     inline void op_7XNN();
     inline void op_8XY0();
     inline void op_8XY1();
     inline void op_8XY2();
     inline void op_8XY3();
     inline void op_8XY4();
     inline void op_8XY5();
     inline void op_8XY6();
     inline void op_8XY7();
     inline void op_8XYE();
     inline void op_9XY0();
     inline void op_ANNN();
     inline void op_BNNN();
     inline void op_CXNN();
     inline void op_DXYN();
     inline void op_EX9E();
     inline void op_EXA1();
     inline void op_FX07();
     inline void op_FX0A();
     inline void op_FX15();
     inline void op_FX18();
     inline void op_FX1E();
     inline void op_FX29();
     inline void op_FX33();
     inline void op_FX55();
     inline void op_FX65();

     void init();

     unsigned short pc;
     unsigned short opcode;
     unsigned short I;
     unsigned short sp;

     unsigned char V[];
     unsigned short stack[];
     unsigned char memory[];

     unsigned char delay_timer;
     unsigned char sound_timer;
 };

 #endif

 #define _CRT_SECURE_NO_WARNINGS 1

 #include "Chip8.h"
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>

 unsigned char fontset[] =
 {
     0xF0, 0x90, 0x90, 0x90, 0xF0, //
     0x20, 0x60, 0x20, 0x20, 0x70, //
     0xF0, 0x10, 0xF0, 0x80, 0xF0, //
     0xF0, 0x10, 0xF0, 0x10, 0xF0, //
     0x90, 0x90, 0xF0, 0x10, 0x10, //
     0xF0, 0x80, 0xF0, 0x10, 0xF0, //
     0xF0, 0x80, 0xF0, 0x90, 0xF0, //
     0xF0, 0x10, 0x20, 0x40, 0x40, //
     0xF0, 0x90, 0xF0, 0x90, 0xF0, //
     0xF0, 0x90, 0xF0, 0x10, 0xF0, //
     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
 };

 void Chip8::init()
 {
     pc = 0x200;
     opcode = ;
     I = ;
     sp = ;
     delay_timer = ;
     sound_timer = ;
     drawFlag = true;

     memset(memory, , sizeof(memory));
     memset(V, , sizeof(V));
     memset(gfx, , sizeof(gfx));
     memset(stack, , sizeof(stack));
     memset(key, , sizeof(key));

     for(int i = ; i < ; ++i) {
         memory[i] = fontset[i];
     }
     srand((unsigned int)time(NULL));
 }

 bool Chip8::loadApplication(const char* fileName)
 {
     init();
     FILE* file = fopen(fileName, "rb");
     fseek(file, , SEEK_END);
     int fileSize = ftell(file);
     rewind(file);
     char* buffer = (char*)malloc(sizeof(char) * fileSize);
     fread(buffer, sizeof(char), fileSize, file);
     for(int i = ; i < fileSize; ++i) {
         memory[+i] = buffer[i];
     }
     fclose(file);
     free(buffer);
     return true;
 }

 void Chip8::emulateCycle()
 {
     opcode = memory[pc] <<  | memory[pc+];
     switch(opcode & 0xF000) {
     case 0x0000:
         switch(opcode & 0x000F) {
         case 0x0000:
             op_00E0(); break;
         case 0x000E:
             op_00EE(); break;
         }
         break;
     case 0x1000:
         op_1NNN(); break;
     case 0x2000:
         op_2NNN(); break;
     case 0x3000:
         op_3XNN(); break;
     case 0x4000:
         op_4XNN(); break;
     case 0x5000:
         op_5XY0(); break;
     case 0x6000:
         op_6XNN(); break;
     case 0x7000:
         op_7XNN(); break;
     case 0x8000:
         switch(opcode & 0x000F) {
         case 0x0000:
             op_8XY0(); break;
         case 0x0001:
             op_8XY1(); break;
         case 0x0002:
             op_8XY2(); break;
         case 0x0003:
             op_8XY3(); break;
         case 0x0004:
             op_8XY4(); break;
         case 0x0005:
             op_8XY5(); break;
         case 0x0006:
             op_8XY6(); break;
         case 0x0007:
             op_8XY7(); break;
         case 0x000E:
             op_8XYE(); break;
         }
         break;
     case 0x9000:
         op_9XY0(); break;
     case 0xA000:
         op_ANNN(); break;
     case 0xB000:
         op_BNNN(); break;
     case 0xC000:
         op_CXNN(); break;
     case 0xD000:
         op_DXYN(); break;
     case 0xE000:
         switch(opcode & 0x000F) {
         case 0x000E:
             op_EX9E(); break;
         case 0x0001:
             op_EXA1(); break;
         }
         break;
     case 0xF000:
         switch(opcode & 0x00FF) {
         case 0x0007:
             op_FX07(); break;
         case 0x000A:
             op_FX0A(); break;
         case 0x0015:
             op_FX15(); break;
         case 0x0018:
             op_FX18(); break;
         case 0x001E:
             op_FX1E(); break;
         case 0x0029:
             op_FX29(); break;
         case 0x0033:
             op_FX33(); break;
         case 0x0055:
             op_FX55(); break;
         case 0x0065:
             op_FX65(); break;
         }
     }
     if(delay_timer > ) {
         --delay_timer;
     }
     if(sound_timer > ) {
         --sound_timer;
     }
 }

 void Chip8::op_0NNN()
 {
 }

 void Chip8::op_00E0()
 {
     memset(gfx, , sizeof(gfx));
     drawFlag = true;
     pc += ;
 }

 void Chip8::op_00EE()
 {
     pc = stack[--sp] + ;
 }

 void Chip8::op_1NNN()
 {
     pc = opcode & 0x0FFF;
 }

 void Chip8::op_2NNN()
 {
     stack[sp++] = pc;
     pc = opcode & 0x0FFF;
 }

 void Chip8::op_3XNN()
 {
     pc += (V[(opcode & 0x0F00) >> ] == (opcode & 0x00FF)) ?  : ;
 }

 void Chip8::op_4XNN()
 {
     pc += (V[(opcode & 0x0F00) >> ] != (opcode & 0x00FF)) ?  : ;
 }

 void Chip8::op_5XY0()
 {
     pc += (V[(opcode & 0x0F00) >> ] == V[(opcode & 0x00F0) >> ]) ?  : ;
 }

 void Chip8::op_6XNN()
 {
     V[(opcode & 0x0F00) >> ] = opcode & 0x00FF;
     pc += ;
 }

 void Chip8::op_7XNN()
 {
     V[(opcode & 0x0F00) >> ] += opcode & 0x00FF;
     pc += ;
 }

 void Chip8::op_8XY0()
 {
     V[(opcode & 0x0F00) >> ] = V[(opcode & 0x00F0) >> ];
     pc += ;
 }

 void Chip8::op_8XY1()
 {
     V[(opcode & 0x0F00) >> ] |= V[(opcode & 0x00F0) >> ];
     pc += ;
 }

 void Chip8::op_8XY2()
 {
     V[(opcode & 0x0F00) >> ] &= V[(opcode & 0x00F0) >> ];
     pc += ;
 }

 void Chip8::op_8XY3()
 {
     V[(opcode & 0x0F00) >> ] ^= V[(opcode & 0x00F0) >> ];
     pc += ;
 }

 void Chip8::op_8XY4()
 {
     V[0xF] = V[(opcode & 0x00F0) >> ] > (0xFF - V[(opcode &0x0F00) >> ]);
     V[(opcode & 0x0F00) >> ] += V[(opcode & 0x00F0) >> ];
     pc += ;
 }

 void Chip8::op_8XY5()
 {
     V[0xF] = !(V[(opcode & 0x00F0) >> ] > V[(opcode & 0x0F00) >> ]);
     V[(opcode & 0x0F00) >> ] -= V[(opcode & 0x00F0) >> ];
     pc += ;
 }

 void Chip8::op_8XY6()
 {
     V[0xF] = V[(opcode & 0x0F00) >> ] & 0x1;
     V[(opcode & 0x0F00) >> ] >>= ;
     pc += ;
 }

 void Chip8::op_8XY7()
 {
     V[0xF] = !(V[(opcode & 0x0F00) >> ] > V[(opcode & 0x00F0) >> ]);
     V[(opcode & 0x0F00) >> ] = V[(opcode & 0x00F0) >> ] - V[(opcode & 0x0F00) >> ];
     pc += ;
 }

 void Chip8::op_8XYE()
 {
     V[0xF] = V[(opcode & 0x0F00) >> ] >> ;
     V[(opcode & 0x0F00) >> ] <<= ;
     pc += ;
 }

 void Chip8::op_9XY0()
 {
     pc += (V[(opcode & 0x0F00) >> ] != V[(opcode & 0x00F0) >> ]) ?  : ;
 }

 void Chip8::op_ANNN()
 {
     I = opcode & 0x0FFF;
     pc += ;
 }

 void Chip8::op_BNNN()
 {
     pc = (opcode & 0x0FFF) + V[];
 }

 void Chip8::op_CXNN()
 {
     V[(opcode & 0x0F00) >> ] = (rand() % 0xFF) & (opcode & 0x00FF);
     pc += ;
 }

 void Chip8::op_DXYN()
 {
     unsigned short x = V[(opcode & 0x0F00) >> ];
     unsigned short y = V[(opcode & 0x00F0) >> ];
     unsigned short height = opcode & 0x000F;
     unsigned short pixel = ;
     V[0xF] = ;
     for(int yline = ; yline < height; ++yline) {
         pixel = memory[I+yline];
         for(int xline = ; xline < ; ++xline) {
             if((pixel & (0x80 >> xline)) != )
             {
                 if(gfx[(x + xline + ((y + yline) * ))] == )
                 {
                     V[0xF] = ;
                 }
                 gfx[x + xline + ((y + yline) * )] ^= ;
             }
         }
     }
     drawFlag = true;
     pc += ;
 }

 void Chip8::op_EX9E()
 {
     pc += (key[V[(opcode & 0x0F00) >> ]]) ?  : ;
 }

 void Chip8::op_EXA1()
 {
     pc += (key[V[(opcode & 0x0F00) >> ]]) ?  : ;
 }

 void Chip8::op_FX07()
 {
     V[(opcode & 0x0F00) >> ] = delay_timer;
     pc += ;
 }

 void Chip8::op_FX0A()
 {
     bool keyPress = false;

     for(int i = ; i < ; ++i)
     {
         if(key[i] != )
         {
             V[(opcode & 0x0F00) >> ] = i;
             keyPress = true;
         }
     }

     if(!keyPress) {
         return;
     }
     pc += ;
 }

 void Chip8::op_FX15()
 {
     delay_timer = V[(opcode & 0x0F00) >> ];
     pc += ;
 }

 void Chip8::op_FX18()
 {
     sound_timer = V[(opcode & 0x0F00) >> ];
     pc += ;
 }

 void Chip8::op_FX1E()
 {
     V[0xF] = (I + V[(opcode & 0x0F00) >> ]) > 0xFFF;
     I += V[(opcode & 0x0F00) >> ];
     pc += ;
 }

 void Chip8::op_FX29()
 {
     I = V[(opcode & 0x0F00) >> ] * ;
     pc += ;
 }

 void Chip8::op_FX33()
 {
     unsigned short vx = V[(opcode & 0x0F00) >> ];
     memory[I] = vx / ;
     memory[I+] = vx /  % ;
     memory[I+] = vx % ;
     pc += ;
 }

 void Chip8::op_FX55()
 {
     unsigned short vx = V[(opcode & 0x0F00) >> ];
     for(int i = ; i <= vx; ++i) {
         memory[I+i] = V[i];
     }
     I += ((opcode & 0x0F00) >> ) + ;
     pc += ;
 }

 void Chip8::op_FX65()
 {
     unsigned short vx = V[(opcode & 0x0F00) >> ];
     for(int i = ; i <= vx; ++i) {
         V[i] = memory[I+i];
     }
     I += ((opcode & 0x0F00) >> ) + ;
     pc += ;
 }