package chip8
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"math/rand"
|
|
)
|
|
|
|
// W represents the width of the screen
|
|
const W = 64
|
|
|
|
// H represents the height of the screen
|
|
const H = 32
|
|
|
|
// Chip8 contains all the data and methods for the Chip8 emulator
|
|
type Chip8 struct {
|
|
opcode uint16
|
|
memory [4096]byte
|
|
|
|
// register
|
|
v [16]byte
|
|
|
|
index uint16
|
|
pc uint16
|
|
|
|
Gfx [W * H]byte
|
|
|
|
delayTimer byte
|
|
soundTimer byte
|
|
|
|
stack [16]uint16
|
|
sp int
|
|
|
|
Key [16]byte
|
|
|
|
DrawFlag bool
|
|
}
|
|
|
|
// Initialize registers and memory
|
|
func NewChip8() Chip8 {
|
|
c := Chip8{}
|
|
c.pc = 0x200
|
|
c.opcode = 0
|
|
c.index = 0
|
|
c.sp = 0
|
|
|
|
for i := 0; i < len(fontSet); i++ {
|
|
c.memory[i] = fontSet[i]
|
|
}
|
|
return c
|
|
}
|
|
|
|
// EmulateCycle emulates the chip8 cycle
|
|
func (c *Chip8) EmulateCycle() {
|
|
// Fetch Opcode
|
|
c.opcode = uint16(c.memory[c.pc])<<8 | uint16(c.memory[c.pc+1])
|
|
x := byte((c.opcode & 0x0F00) >> 8)
|
|
y := byte((c.opcode & 0x00F0) >> 4)
|
|
nn := byte(c.opcode & 0x00FF)
|
|
nnn := uint16(c.opcode & 0x0FFF)
|
|
|
|
// Decode Opcode
|
|
// https://en.wikipedia.org/wiki/CHIP-8#Opcode_table
|
|
switch c.opcode & 0xF000 {
|
|
case 0x0000:
|
|
switch c.opcode & 0x000F {
|
|
case 0x0000:
|
|
// 00E0 Clear screen
|
|
for i := 0; i < len(c.Gfx); i++ {
|
|
c.Gfx[i] = 0
|
|
}
|
|
c.pc += 2
|
|
c.DrawFlag = true
|
|
case 0x000E:
|
|
// 00EE Returns from a subroutine
|
|
c.sp--
|
|
c.pc = c.stack[c.sp]
|
|
c.pc += 2
|
|
default:
|
|
fmt.Printf("Unknown opcode [0x0000]: 0x%X\n", c.opcode)
|
|
}
|
|
case 0x1000:
|
|
// 1NNN Jumps to address NNN
|
|
c.pc = nnn
|
|
case 0x2000:
|
|
// 2NNN Calls subroutine at NNN
|
|
c.stack[c.sp] = c.pc
|
|
c.sp++
|
|
c.pc = nnn
|
|
case 0x3000:
|
|
// 3XNN Skips the next instruction if VX equals NN. (Usually
|
|
// the next instruction is a jump to skip a code block)
|
|
if c.v[x] == nn {
|
|
c.pc += 2
|
|
}
|
|
c.pc += 2
|
|
case 0x4000:
|
|
// 4XNN Skips the next instruction if VX doesn't equal NN.
|
|
// (Usually the next instruction is a jump to skip a code
|
|
// block)
|
|
if c.v[x] != nn {
|
|
c.pc += 2
|
|
}
|
|
c.pc += 2
|
|
case 0x5000:
|
|
// 5XY0 Skips the next instruction if VX equals VY. (Usually
|
|
// the next instruction is a jump to skip a code block)
|
|
if c.v[x] == c.v[y] {
|
|
c.pc += 2
|
|
}
|
|
c.pc += 2
|
|
case 0x6000:
|
|
// 6XNN Sets VX to NN
|
|
c.v[x] = nn
|
|
c.pc += 2
|
|
case 0x7000:
|
|
// 7XNN Adds NN to VX. (Carry flag is not changed)
|
|
c.v[x] += nn
|
|
c.pc += 2
|
|
case 0x8000:
|
|
switch c.opcode & 0x000F {
|
|
case 0x0000:
|
|
// 0x8XY0 Sets VX to the value of VY
|
|
c.v[x] = c.v[y]
|
|
c.pc += 2
|
|
case 0x0001:
|
|
// 0x8XY1 Sets VX to VX or VY. (Bitwise OR operation)
|
|
c.v[x] = (c.v[x] | c.v[y])
|
|
c.pc += 2
|
|
case 0x0002:
|
|
// 0x8XY2 Sets VX to VX and VY. (Bitwise AND operation)
|
|
c.v[x] = (c.v[x] & c.v[y])
|
|
c.pc += 2
|
|
case 0x0003:
|
|
// 0x8XY3 Sets VX to VX xor VY
|
|
c.v[x] = (c.v[x] ^ c.v[y])
|
|
c.pc += 2
|
|
case 0x0004:
|
|
// 0x8XY4 Adds VY to VX. VF is set to 1 when there's a
|
|
// carry, and to 0 when there isn't
|
|
if c.v[y] > (0xFF - c.v[x]) {
|
|
c.v[0xF] = 1
|
|
} else {
|
|
c.v[0xF] = 0
|
|
}
|
|
c.v[x] += c.v[y]
|
|
c.pc += 2
|
|
case 0x0005:
|
|
// 0x8XY5 VY is subtracted from VX. VF is set to 0 when
|
|
// there's a borrow, and 1 when there isn't
|
|
if c.v[x] > c.v[y] {
|
|
c.v[0xF] = 1
|
|
} else {
|
|
c.v[0xF] = 0
|
|
}
|
|
c.v[x] -= c.v[y]
|
|
c.pc += 2
|
|
case 0x0006:
|
|
// 0x8XY6 Stores the least significant bit of VX in VF
|
|
// and then shifts VX to the right by 1
|
|
if c.opcode&0x1 >= 1 {
|
|
c.v[0xF] = 1
|
|
} else {
|
|
c.v[0xF] = 0
|
|
}
|
|
c.v[x] = c.v[x] >> 1
|
|
c.pc += 2
|
|
case 0x0007:
|
|
// 0x8XY7 Sets VX to VY minus VX. VF is set to 0 when
|
|
// there's a borrow, and 1 when there isn't
|
|
if c.v[y] > c.v[x] {
|
|
c.v[0xF] = 1
|
|
} else {
|
|
c.v[0xF] = 0
|
|
}
|
|
c.v[x] = c.v[y] - c.v[x]
|
|
c.pc += 2
|
|
case 0x000E:
|
|
// 0x8XYE Stores the most significant bit of VX in VF
|
|
// and then shifts VX to the left by 1
|
|
if c.opcode&0x80 == 0x80 {
|
|
c.v[0xF] = 1
|
|
} else {
|
|
c.v[0xF] = 0
|
|
}
|
|
c.v[x] = c.v[x] << 1
|
|
c.pc += 2
|
|
default:
|
|
fmt.Printf("Unknown opcode [0x8000]: 0x%X\n", c.opcode)
|
|
}
|
|
case 0x9000:
|
|
// 9XY0 Skips the next instruction if VX doesn't equal VY.
|
|
// (Usually the next instruction is a jump to skip a code
|
|
// block)
|
|
if c.v[x] != c.v[y] {
|
|
c.pc += 2
|
|
}
|
|
c.pc += 2
|
|
case 0xA000:
|
|
// ANNN set index to NNN position
|
|
c.index = nnn
|
|
c.pc += 2
|
|
case 0xB000:
|
|
// BNNN Jumps to the address NNN plus V0
|
|
c.pc = nnn + uint16(c.v[0])
|
|
case 0xC000:
|
|
// CXNN Sets VX to the result of a bitwise and operation on a
|
|
// random number (Typically: 0 to 255) and NN
|
|
r := byte(rand.Intn(255))
|
|
c.v[x] = r & nn
|
|
c.pc += 2
|
|
case 0xD000:
|
|
// DXYN Draws a sprite at coordinate (VX, VY) that has a width
|
|
// of 8 pixels and a height of N+1 pixels. Each row of 8 pixels
|
|
// is read as bit-coded starting from memory location I; I
|
|
// value doesn’t change after the execution of this
|
|
// instruction. As described above, VF is set to 1 if any
|
|
// screen pixels are flipped from set to unset when the sprite
|
|
// is drawn, and to 0 if that doesn’t happen
|
|
|
|
height := c.opcode & 0x000F
|
|
|
|
var pixel byte
|
|
c.v[0xF] = 0
|
|
|
|
for yline := uint16(0); yline < height; yline++ {
|
|
pixel = c.memory[c.index+yline]
|
|
for xline := uint16(0); xline < 8; xline++ {
|
|
if (pixel & (0x80 >> xline)) != 0 {
|
|
pos := (uint16(c.v[x]) + xline) + ((uint16(c.v[y]) + yline) * W)
|
|
if pos >= 2048 {
|
|
break
|
|
}
|
|
if c.Gfx[pos] == 1 {
|
|
c.v[0xF] = 1
|
|
}
|
|
c.Gfx[pos] ^= 1
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
c.DrawFlag = true
|
|
c.pc += 2
|
|
case 0xE000:
|
|
switch c.opcode & 0x00FF {
|
|
case 0x009E:
|
|
// EX9E Skips the next instruction if the key stored in
|
|
// VX is pressed. (Usually the next instruction is a
|
|
// jump to skip a code block)
|
|
if c.Key[c.v[x]] != 0 {
|
|
c.pc += 2
|
|
}
|
|
c.pc += 2
|
|
case 0x00A1:
|
|
// EXA1 Skips the next instruction if the key stored in
|
|
// VX isn't pressed. (Usually the next instruction is a
|
|
// jump to skip a code block)
|
|
if c.Key[c.v[x]] != 1 {
|
|
c.pc += 2
|
|
}
|
|
c.pc += 2
|
|
default:
|
|
fmt.Printf("Unknown opcode [0xE000]: 0x%X\n", c.opcode)
|
|
}
|
|
case 0xF000:
|
|
switch c.opcode & 0x00FF {
|
|
case 0x0007:
|
|
// FX07 Sets VX to the value of the delay timer
|
|
c.v[x] = c.delayTimer
|
|
c.pc += 2
|
|
case 0x000A:
|
|
// FX0A A key press is awaited, and then stored in VX.
|
|
// (Blocking Operation. All instruction halted until
|
|
// next key event)
|
|
pressed := false
|
|
for i := 0; i < 16; i++ {
|
|
if c.Key[i] == 1 {
|
|
c.v[x] = byte(i)
|
|
pressed = true
|
|
}
|
|
}
|
|
if !pressed {
|
|
return
|
|
}
|
|
c.pc += 2
|
|
case 0x0015:
|
|
// FX15 Sets the delay timer to VX
|
|
c.delayTimer = c.v[x]
|
|
c.pc += 2
|
|
case 0x0018:
|
|
// FX18 Sets the sound timer to VX
|
|
c.soundTimer = c.v[x]
|
|
c.pc += 2
|
|
case 0x001E:
|
|
// FX1E Adds VX to I. VF is not affected
|
|
c.index += uint16(c.v[x])
|
|
c.pc += 2
|
|
case 0x0029:
|
|
// FX29 Sets I to the location of the sprite for the
|
|
// character in VX. Characters 0-F (in hexadecimal) are
|
|
// represented by a 4x5 font
|
|
c.index = uint16(c.v[x]) * 5
|
|
c.pc += 2
|
|
case 0x0033:
|
|
c.memory[c.index] = c.v[x] / 100
|
|
c.memory[c.index+1] = (c.v[x] / 10) % 10
|
|
c.memory[c.index+2] = (c.v[x] / 100) % 10
|
|
c.pc += 2
|
|
case 0x0055:
|
|
// FX55 Stores V0 to VX (including VX) in memory
|
|
// starting at address I. The offset from I is
|
|
// increased by 1 for each value written, but I itself
|
|
// is left unmodified
|
|
for i := uint16(0); i <= uint16(x); i++ {
|
|
c.memory[c.index+i] = c.v[i]
|
|
}
|
|
c.pc += 2
|
|
case 0x0065:
|
|
// 0xFX65 Fills V0 to VX (including VX) with values
|
|
// from memory starting at address I. The offset from I
|
|
// is increased by 1 for each value written, but I
|
|
// itself is left unmodified
|
|
for i := uint16(0); i <= uint16(x); i++ {
|
|
c.v[i] = c.memory[c.index+i]
|
|
}
|
|
c.pc += 2
|
|
default:
|
|
fmt.Printf("Unknown opcode [0xF000]: 0x%X\n", c.opcode)
|
|
}
|
|
default:
|
|
fmt.Printf("Unknown opcode: 0x%X\n", c.opcode)
|
|
}
|
|
|
|
// Update timers
|
|
if c.delayTimer > 0 {
|
|
c.delayTimer--
|
|
}
|
|
if c.soundTimer > 0 {
|
|
if c.soundTimer == 1 {
|
|
fmt.Printf("Beep!\n")
|
|
}
|
|
c.soundTimer--
|
|
}
|
|
}
|
|
|
|
// LoadGame loads the rom file of the given file path into the Chip8 memory
|
|
func (c *Chip8) LoadGame(filepath string) error {
|
|
buffer, err := ioutil.ReadFile(filepath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
for i := 0; i < len(buffer); i++ {
|
|
// 0x200 == 512
|
|
c.memory[512+i] = buffer[i]
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var fontSet = [80]byte{
|
|
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
|
|
}
|