Эмулятор CHIP-8

/**************************************************************
* TYPES.H                                                     *
* Emulator CHIP-8                                             *
*                                                             *
* basic typedef and constants                                 *
*                                                             *
* LAST UPD: 09/08/2010                                        *
*                                                             *
* by Lavroff and fasked (c)                                   *
**************************************************************/
 
#ifndef HEADER_TYPES_H
#define HEADER_TYPES_H
 
typedef unsigned char  BYTE;
typedef unsigned short WORD;
 
#define DATA_REG_SIZE   16
#define ADDR_REG_SIZE   4096
#define STACK_SIZE      16
 
#define SCREEN_VER_SIZE 32
#define SCREEN_HOR_SIZE 64 
 
#define VIDEO_MEM_SIZE (SCREEN_HOR_SIZE * SCREEN_VER_SIZE)
 
#endif /* HEADER_TYPES_H */

/**************************************************************
* CHIP8.H                                                     *
* Emulator CHIP-8                                             *
*                                                             *
* basic declarations                                          *
*                                                             *
* LAST UPD: 09/08/2010                                        *
*                                                             *
* by Lavroff and fasked (c)                                   *
**************************************************************/
 
#ifndef _HEADER_CHIP8_H_
#define _HEADER_CHIP8_H_
 
#include "types.h"
 
//Declaration of global variables and arrays
static BYTE dataRegisters[DATA_REG_SIZE];
static BYTE addrRegisters[ADDR_REG_SIZE];
 
static WORD stackMemory[STACK_SIZE];
static BYTE videoMemory[VIDEO_MEM_SIZE];
 
static BYTE soundTimer;
static BYTE delayTimer;
 
static WORD iRegister;
 
static BYTE stackCounter;
static WORD offsetMemory;
 
const static BYTE font[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
};
 
//Declaration of macro
#define START_OFFSET 200
 
#define DATA_REG_VX(n)\
   (dataRegisters[(0x0F00 & n) >> 8])
 
#define DATA_REG_VY(n)\
   (dataRegisters[(0x00F0 & n) >> 4])
 
#define DATA_REG_VF\
   (dataRegisters[0xF])
 
#define DATA_REG_V0\
   (dataRegisters[0x0])
 
//Declaration of functions
void InitialiseEmulator();
void EmulatorRun();
 
void LoadOpcodes(WORD * opcodes);
 
WORD GetOpcode();
void ExecuteOpcode (WORD opcode);
 
void ExecuteOpcode0(WORD opcode);
void ExecuteOpcode1(WORD opcode);
void ExecuteOpcode2(WORD opcode);
void ExecuteOpcode3(WORD opcode);
void ExecuteOpcode4(WORD opcode);
void ExecuteOpcode5(WORD opcode);
void ExecuteOpcode6(WORD opcode);
void ExecuteOpcode7(WORD opcode);
void ExecuteOpcode8(WORD opcode);
void ExecuteOpcode9(WORD opcode);
void ExecuteOpcodeA(WORD opcode);
void ExecuteOpcodeB(WORD opcode);
void ExecuteOpcodeC(WORD opcode);
void ExecuteOpcodeD(WORD opcode);
void ExecuteOpcodeE(WORD opcode);
void ExecuteOpcodeF(WORD opcode);
 
void RedrawScreen();
void Delay();
void SoundPlay();
 
#endif /* HEADER_CHIP8_H */

#include <iostream>
#include <windows.h>
#include "chip8.h"
 
void RedrawScreen()
{
   system("cls");
   for(int i = 0; i < SCREEN_HOR_SIZE; ++i)
   {
      for(int j = 0; j < SCREEN_VER_SIZE; ++j)
      {
         if(videoMemory[i * SCREEN_HOR_SIZE + j])
            printf("*");
         else
            printf(" ");
      }
 
      printf("\n");
   }
}
 
void Delay()
{
   if(delayTimer)
   {
      Sleep(delayTimer*1000);
   }
}
 
void SoundPlay()
{
   if(soundTimer)
   {
      for(int i=0;i<soundTimer;++i)
         std::cout<<'\a'<<std::endl;
   }
}
 
void InitialiseEmulator()
{
   stackCounter = 0;
   soundTimer = 0;
   delayTimer = 0;
 
   offsetMemory = START_OFFSET;
   iRegister = START_OFFSET;
 
   memset(dataRegisters, 0, DATA_REG_SIZE * sizeof(BYTE));
   memset(addrRegisters, 0, ADDR_REG_SIZE * sizeof(BYTE));
   memset(videoMemory, 0, VIDEO_MEM_SIZE * sizeof(BYTE));
   memset(stackMemory, 0, STACK_SIZE * sizeof(WORD));
   memcpy(addrRegisters, font, 80);
}
 
void LoadOpcodes(WORD * opcodes)
{
   memcpy(addrRegisters + offsetMemory, opcodes, ADDR_REG_SIZE * sizeof(BYTE));
}
 
WORD GetOpcode()
{
   return *(WORD*)(addrRegisters + offsetMemory); // TODO исправить на более правильный вариант
}
 
void EmulatorRun()
{
   WORD opcode = 0;
   for(;;)
   {
      opcode = GetOpcode();
//#ifdef _DEBUG
//      printf("%s: %#0.4x | %s: %#0.4x\n", "OFFSET", offsetMemory, "OPCODE", opcode);
//#endif
 
      if(opcode == 0)
         break;
 
      ExecuteOpcode(opcode);
 
      offsetMemory += 2;
 
      SoundPlay();
      Delay();
      //RedrawScreen();
   }
}
 
void ExecuteOpcode0(WORD opcode)
{
   if((opcode & 0x00FF) == 0xE0)
      memset(videoMemory, 0, VIDEO_MEM_SIZE * sizeof(BYTE)); // 0x00E0: Clear the Screen
   
   else if((opcode & 0x00FF) == 0xEE)
   {
      --stackCounter;
      offsetMemory = stackMemory[stackCounter];
   }
 
   else if((opcode & 0xF000) == 0)
   {
      //TODO 0NNN-Opcode
   }
}
 
void ExecuteOpcode1(WORD opcode)
{
   offsetMemory = opcode & 0x0FFF;
}
 
void ExecuteOpcode2(WORD opcode)
{
   if(stackCounter < 16)
   {
      stackMemory[stackCounter] = offsetMemory;
      ++stackCounter;
   }
 
   offsetMemory = opcode & 0x0FFF;
}
 
void ExecuteOpcode3(WORD opcode)
{
   if(DATA_REG_VX(opcode) == (opcode & 0x00FF))
      offsetMemory += 2;
}
 
void ExecuteOpcode4(WORD opcode)
{
   if(DATA_REG_VX(opcode) != (opcode & 0x00FF))
      offsetMemory += 2;
}
 
void ExecuteOpcode5(WORD opcode)
{
   if(DATA_REG_VX(opcode) == DATA_REG_VY(opcode))
      offsetMemory += 2;
}
 
void ExecuteOpcode6(WORD opcode)
{
   DATA_REG_VX(opcode) = 0x00FF & opcode;
}
 
void ExecuteOpcode7(WORD opcode)
{
   DATA_REG_VX(opcode) += 0x00FF & opcode;
}
 
void ExecuteOpcode8(WORD opcode)
{
   if((opcode & 0xF) == 0x0)
      DATA_REG_VX(opcode) = DATA_REG_VY(opcode);
   
   else if((opcode & 0xF) == 0x1)
      DATA_REG_VX(opcode) |= DATA_REG_VY(opcode);
 
   else if((opcode & 0xF) == 0x2)
      DATA_REG_VX(opcode) &= DATA_REG_VY(opcode);
 
   else if((opcode & 0xF) == 0x3)
      DATA_REG_VX(opcode) ^= DATA_REG_VY(opcode);
 
   else if((opcode & 0xF) == 0x4)
   {
      WORD t = DATA_REG_VX(opcode) + DATA_REG_VY(opcode);
      DATA_REG_VX(opcode) = (BYTE)t;
      DATA_REG_VF = (BYTE)(t & 0x100); 
   }
 
   else if((opcode & 0xF) == 0x5)
   {
      WORD t = DATA_REG_VX(opcode) - DATA_REG_VY(opcode);
      DATA_REG_VX(opcode) = (BYTE)t;
      DATA_REG_VF = (BYTE)((t & 0x100) >> 8);
   }
 
   else if((opcode & 0xF) == 0x6)
   {
      DATA_REG_VF = DATA_REG_VX(opcode) & 1;
      DATA_REG_VX(opcode) >>= 1;
   }
 
   else if((opcode & 0xF) == 0x7)
   {
      WORD t= DATA_REG_VY(opcode)- DATA_REG_VX(opcode);
      DATA_REG_VX(opcode) = (BYTE)t;
      DATA_REG_VF = (BYTE)((t & 0x100) >> 8);
   }
 
   else if((opcode & 0xF) == 0xE)
   {
      DATA_REG_VF = DATA_REG_VX(opcode) & 0x80;
      DATA_REG_VX(opcode) <<= 1;
   }
}
 
void ExecuteOpcode9(WORD opcode)
{
   if(DATA_REG_VX(opcode) != DATA_REG_VY(opcode))
      offsetMemory+=2;  
}
 
void ExecuteOpcodeA(WORD opcode)
{
   iRegister = opcode & 0x0FFF;
}
 
void ExecuteOpcodeB(WORD opcode)
{
   offsetMemory = (opcode & 0x0FFF) + dataRegisters[0];
}
 
void ExecuteOpcodeC(WORD opcode)
{
   DATA_REG_VX(opcode) = (BYTE)(rand()) & (opcode & 0x00FF);
}
 
void ExecuteOpcodeD(WORD opcode)
{
   // TODO D-opcode
   WORD x = DATA_REG_VX(opcode);
   WORD y = DATA_REG_VY(opcode);
   WORD h = opcode & 0x000F;
 
   for(int i = 0; i < h; ++i)
   {
      WORD data = addrRegisters[i + iRegister];
      
      for(int j = 0; j < 8; ++j)
      {
         if((data & (0x80 >> i)) != 0)
         {
            if(videoMemory[j + x + (( y + i ) * SCREEN_HOR_SIZE)] == 1)
               DATA_REG_VF = 1;
            else
               DATA_REG_VF=0;
 
            videoMemory[j + x + (( y + i ) * SCREEN_HOR_SIZE)] ^= 1;
         }
      }
   }
}
 
void ExecuteOpcodeE(WORD opcode)
{
  if((opcode & 0x00FF) == 0x9E)
  {
     // TODO EX9E-Opcode. Keyboard
  }
  else if((opcode & 0x00FF) == 0xA1) 
  {
     // TODO EXA1-Opcode. Keyboard
  }
}
 
void ExecuteOpcodeF(WORD opcode)
{
  if((opcode & 0x000F) == 0x7)
     DATA_REG_VX(opcode) = delayTimer;
 
  else if((opcode & 0x000F) == 0xA)
  {
     //TODO FX0A opcode
  }
  
  else if((opcode & 0x00FF) == 0x15)
     delayTimer = DATA_REG_VX(opcode);
  
  else if((opcode & 0x00FF) == 0x18)
     soundTimer = DATA_REG_VX(opcode);
  
  else if((opcode & 0x00FF) == 0x1E)
     iRegister += DATA_REG_VX(opcode);
  
  else if((opcode & 0x00FF) == 0x29)
  {
     iRegister=DATA_REG_VX(opcode);
  }
  
  else if((opcode & 0x00FF) == 0x33)
  {
     addrRegisters[iRegister] = DATA_REG_VX(opcode) / 100;
     addrRegisters[iRegister + 1] = (DATA_REG_VX(opcode) % 100) / 10;
     addrRegisters[iRegister + 2] = DATA_REG_VX(opcode) % 10;
  }
  
  else if((opcode & 0x00FF) == 0x55)
  {
     for(int i = 0; i < ((opcode & 0x0F00) >> 8); ++i)
        addrRegisters[i + iRegister] = dataRegisters[i];  
  }
  
  else if((opcode & 0x00FF) == 0x65)
  {
     for(int i = 0; i < ((opcode & 0x0F00) >> 8); ++i)
        dataRegisters[i] = addrRegisters[i + iRegister];
  }
} 
 
void ExecuteOpcode(WORD opcode)
{
  WORD opcodeGroup = opcode >> 12; // выделить старшие 4 бита
 
  switch(opcodeGroup)
  {
  case 0x0:
     ExecuteOpcode0(opcode);
     break;
  case 0x1:
     ExecuteOpcode1(opcode);
     break;
  case 0x2:
     ExecuteOpcode2(opcode);
     break;
  case 0x3:
     ExecuteOpcode3(opcode);
     break;
  case 0x4:
     ExecuteOpcode4(opcode);
     break;
  case 0x5:
     ExecuteOpcode5(opcode);
     break;
  case 0x6:
     ExecuteOpcode6(opcode);
     break;
  case 0x7:
     ExecuteOpcode7(opcode);
     break;
  case 0x8:
     ExecuteOpcode8(opcode);
     break;
  case 0x9:
     ExecuteOpcode9(opcode);
     break;
  case 0xA:
     ExecuteOpcodeA(opcode);
     break;
  case 0xB:
     ExecuteOpcodeB(opcode);
     break;
  case 0xC:
     ExecuteOpcodeC(opcode);
     break;
  case 0xD:
     ExecuteOpcodeD(opcode);
     break;
  case 0xE:
     ExecuteOpcodeE(opcode);
     break;
  case 0xF:
     ExecuteOpcodeF(opcode);
     break;
  }
}

#include "chip8.h"
 
int main()
{
   // массив опкодов
   // в дальнейшем должны читаться из файлов 
   // специально откомпилированнынх под CHIP-8
   WORD opcodes[ADDR_REG_SIZE] = { 0x6000, 0x6100, 0xA222, 0xC201, 
                                   0x3201, 0xA2E1, 0xD014, 0x7004, 
                                   0x3040, 0x1204, 0x6000, 0x7104, 
                                   0x3120, 0x1204, 0x121C, 0x8040, 
                                   0x2010, 0x2040, 0x8010, 0x0000
   };  
 
   // Инициализация ЦПУ эмулятора
   // очистка памяти, сброс счетчиков и таймеров
   InitialiseEmulator();
 
   // Загрузка опкодов в память эмулятора
   LoadOpcodes(opcodes);
 
   // Запуск эмулятора
   EmulatorRun();
 
   return 0;
}