329 lines
14 KiB
Python
329 lines
14 KiB
Python
from instruction import Opcode
|
||
import random
|
||
import time
|
||
|
||
|
||
class CPU:
|
||
display = ["．"] * 64 * 32
|
||
drawFlag = False
|
||
|
||
memory = [0x00] * 4096
|
||
stack = [0x00] * 12
|
||
V = [0x00] * 0x10
|
||
PC = 0x200
|
||
SP = 0x00
|
||
I = 0x0000
|
||
|
||
delay_timer = 0x00
|
||
sound_timer = 0x00
|
||
tick_timer = int(round(time.time() * 1000))
|
||
|
||
interrupt = True
|
||
jumps = 0
|
||
|
||
instruction = Opcode
|
||
|
||
def load_rom(self, rom: str):
|
||
with open(rom, "rb") as f:
|
||
byte = f.read(1)
|
||
offset = 0
|
||
while byte != b"":
|
||
self.memory[0x200 + offset] = int.from_bytes(byte, byteorder='little')
|
||
offset += 1
|
||
byte = f.read(1)
|
||
|
||
def reset(self):
|
||
self.display = ["．"] * 64 * 32
|
||
self.drawFlag = False
|
||
|
||
self.memory = [0x00] * 4096
|
||
self.stack = [0x00] * 12
|
||
self.V = [0x00] * 0x10
|
||
self.PC = 0x200
|
||
self.SP = 0x00
|
||
self.I = 0x0000
|
||
|
||
self.delay_timer = 0x00
|
||
self.sound_timer = 0x00
|
||
|
||
self.interrupt = True
|
||
self.jumps = 0
|
||
|
||
self.instruction = Opcode
|
||
self.tick_timer = int(round(time.time() * 1000))
|
||
|
||
def tick(self):
|
||
if self.jumps >= 5 and self.drawFlag is False:
|
||
self.interrupt = True
|
||
self.execute(self, Opcode((self.memory[self.PC] << 8) | self.memory[self.PC + 1]))
|
||
|
||
# print(time.localtime(time.time())[6])
|
||
if (int(round(time.time() * 1000)) - self.tick_timer) >= 1000 / 60:
|
||
if self.delay_timer is not 0:
|
||
self.delay_timer -= 1
|
||
if self.sound_timer is not 0:
|
||
self.sound_timer -= 1
|
||
self.tick_timer = int(round(time.time() * 1000))
|
||
|
||
def execute(self, opc: Opcode):
|
||
self.instruction = opc
|
||
print(hex(self.instruction.op))
|
||
|
||
if opc.i == 0x0: # multi case
|
||
if opc.kk == 0xE0:
|
||
self.display = ["．"] * 64 * 32
|
||
self.PC += 2
|
||
print("Screen cleared")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.kk == 0xEE: # return from subroutine
|
||
self.SP -= 1
|
||
self.PC = self.stack[self.SP]
|
||
self.PC += 2
|
||
print("Returned from subroutine")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x1: # 1NNN: Jump to address NNN
|
||
if hex(opc.nnn) is 0x349:
|
||
print("klklklkl")
|
||
self.PC = opc.nnn
|
||
print("=>Jumped to address " + hex(opc.nnn))
|
||
self.jumps += 1
|
||
return
|
||
|
||
if opc.i == 0x2: # 2NNN Call subroutnie at NNN
|
||
self.stack[self.SP] = self.PC
|
||
self.SP += 1
|
||
self.PC = self.instruction.nnn
|
||
print("=>Called subroutine at " + str(hex(self.instruction.nnn)))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x3: # 3XKK: Skip next instruction if VX == KK
|
||
if self.V[self.instruction.x] == self.instruction.kk:
|
||
self.PC += 4
|
||
print("V" + str(self.instruction.x) + " == KK"
|
||
+ " [" + str(self.V[self.instruction.x]) + " == " + str(self.instruction.kk)
|
||
+ "] || Skipped instruction")
|
||
else:
|
||
self.PC += 2
|
||
print("V" + str(self.instruction.x) + " != KK"
|
||
+ " [" + str(self.V[self.instruction.x]) + " != " + str(self.instruction.kk)
|
||
+ " || Didn't skip instruction")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x4: # 4XKK: Skip next instruction if VX != KK
|
||
if self.V[self.instruction.x] != self.instruction.kk:
|
||
self.PC += 4
|
||
print("V" + str(self.instruction.x) + " != KK"
|
||
+ " [" + str(self.V[self.instruction.x]) + " != " + str(self.instruction.kk)
|
||
+ "] || Skipped instruction")
|
||
else:
|
||
self.PC += 2
|
||
print("V" + str(self.instruction.x) + " == KK"
|
||
+ " [" + str(self.V[self.instruction.x]) + " == " + str(self.instruction.kk)
|
||
+ " || Didn't skip instruction")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x5: # 5XY0: Skip next instruction if VX == VY
|
||
if self.V[self.instruction.x] == self.V[self.instruction.y]:
|
||
self.PC += 4
|
||
print("V" + str(self.instruction.x) + " == V" + str(self.instruction.y)
|
||
+ " [" + str(self.V[self.instruction.x]) + " == " + str(self.V[self.instruction.y])
|
||
+ "] || Skipped instruction")
|
||
else:
|
||
self.PC += 2
|
||
print("V" + str(self.instruction.x) + " != V" + str(self.instruction.y)
|
||
+ " [" + str(self.V[self.instruction.x]) + " != " + str(self.V[self.instruction.y])
|
||
+ " || Didn't skip instruction")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x6: # 6XKK: Set VX to KK
|
||
self.V[self.instruction.x] = opc.kk
|
||
self.PC += 2
|
||
print("=>Set V" + str(self.instruction.x) + " to " + str(opc.kk))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x7: # 7XKK: Set VX = VX + KK
|
||
self.V[self.instruction.x] = (self.V[self.instruction.x] + self.instruction.kk) & 0xFF
|
||
self.PC += 2
|
||
print("=>Added V" + str(self.instruction.x) + " and KK ("
|
||
+ str(self.instruction.kk) + ") = " + str(self.V[self.instruction.x]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x8: # Multi Case
|
||
if opc.n == 0x0: # 8XY0: VX = VY
|
||
self.V[self.instruction.x] = self.V[self.instruction.y]
|
||
self.PC += 2
|
||
print("=>Set V" + str(self.instruction.x) + " = V" + str(self.instruction.y) + " ("
|
||
+ str(self.V[self.instruction.x]) + ")")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.n == 0x2: # 8XY2: VX = VX AND VY
|
||
self.V[self.instruction.x] = (self.V[self.instruction.x] & self.instruction.y)
|
||
self.PC += 2
|
||
print("=>ANDed V" + str(self.instruction.x) + " and V" + str(self.instruction.y) + "("
|
||
+ str(self.V[self.instruction.y]) + ") = " + str(self.V[self.instruction.x]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.n == 0x3: # 8XY3: Set VX = VX XOR VY
|
||
self.V[self.instruction.x] = self.V[self.instruction.x] ^ self.V[self.instruction.y]
|
||
self.PC += 2
|
||
print("=>XORed V" + str(self.instruction.x) + " and V" + str(self.instruction.y) + "("
|
||
+ str(self.V[self.instruction.y]) + ") = " + str(self.V[self.instruction.x]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.n == 0x4: # 8XY4: Set VX = VX + VY. Set Carry if overflow
|
||
self.V[0xF] = 0
|
||
if self.V[self.instruction.y] > (255 - self.V[self.instruction.x]):
|
||
self.V[0xF] = 1
|
||
|
||
self.V[self.instruction.x] = (self.V[self.instruction.x] + self.V[self.instruction.y]) & 0xFF
|
||
self.PC += 2
|
||
print("=>Added V" + str(self.instruction.x) + " and V" + str(self.instruction.y) + "("
|
||
+ str(self.V[self.instruction.y]) + ") = " + str(self.V[self.instruction.x])
|
||
+ " ; Carry is now " + str(self.V[0xF]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.n == 0x5: # 8XY5: Set VX = VX - VY. Set Flag if NOT borrow
|
||
self.V[0xF] = 0
|
||
if self.V[self.instruction.x] > self.V[self.instruction.y]:
|
||
self.V[0xF] = 1
|
||
|
||
self.V[self.instruction.x] = (self.V[self.instruction.x] - self.V[self.instruction.y]) & 0xFF
|
||
self.PC += 2
|
||
print("=>Subtracted V" + str(self.instruction.x) + " and V" + str(self.instruction.y) + "("
|
||
+ str(self.V[self.instruction.y]) + ") = " + str(self.V[self.instruction.x])
|
||
+ " ; Flag is now " + str(self.V[0xF]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.n == 0x6:
|
||
self.V[0xF] = self.V[self.instruction.x] & 0x1
|
||
self.V[self.instruction.x] >>= 0x1
|
||
self.PC += 2
|
||
print("=>Shifted V" + str(self.instruction.x) + " right. Is now: " + str(self.V[self.instruction.x])
|
||
+ " | VF: " + str(self.V[0xF]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.n == 0xE:
|
||
self.V[0xF] = self.V[self.instruction.x] & 0x1
|
||
self.V[self.instruction.x] <<= 0x1
|
||
self.PC += 2
|
||
print("=>Shifted V" + str(self.instruction.x) + " left. Is now: " + str(self.V[self.instruction.x])
|
||
+ " | VF: " + str(self.V[0xF]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0x9: # 9XY0: Skip next instruction if VX != VY
|
||
if self.V[self.instruction.x] != self.V[self.instruction.y]:
|
||
self.PC += 4
|
||
print("V" + str(self.instruction.x) + " != V" + str(self.instruction.y)
|
||
+ " [" + str(self.V[self.instruction.x]) + " != " + str(self.V[self.instruction.y])
|
||
+ "] || Skipped instruction")
|
||
else:
|
||
self.PC += 2
|
||
print("V" + str(self.instruction.x) + " == V" + str(self.instruction.y)
|
||
+ " [" + str(self.V[self.instruction.x]) + " == " + str(self.V[self.instruction.y])
|
||
+ " || Didn't skip instruction")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0xA: # ANNN: Set I = NNN
|
||
self.I = opc.nnn
|
||
self.PC += 2
|
||
print("=>Set I to " + str(hex(opc.nnn)))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0xC: # CXNN: Set VX = random(255) & KK
|
||
self.V[self.instruction.x] = random.randint(0, 255) & self.instruction.kk
|
||
self.PC += 2
|
||
print("Set V" + str(self.instruction.x) + " to " + str(self.V[self.instruction.x]))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0xD: # DXYN: Draw Sprite located at I with height N at X, Y
|
||
self.V[0xF] = 0x00
|
||
|
||
for y in range(0, opc.n):
|
||
line = self.memory[self.I + y]
|
||
print("----" + str(line) + "----")
|
||
for x in range(0, 8):
|
||
pixel = line & (0x80 >> x)
|
||
if pixel is not 0:
|
||
total_x = self.V[self.instruction.x] + x
|
||
total_y = self.V[self.instruction.y] + y
|
||
index = total_y * 64 + total_x
|
||
|
||
if self.display[index] is "＃":
|
||
self.V[0xF] = 1
|
||
|
||
if self.display[index] is "＃":
|
||
self.display[index] = "．"
|
||
else:
|
||
self.display[index] = "＃"
|
||
|
||
self.PC += 2
|
||
self.drawFlag = True
|
||
|
||
print("=>Drew sprite located at " + str(hex(self.I)) + " that is " + str(opc.n)
|
||
+ " bytes long at position (" + str(self.V[self.instruction.x]) + ", "
|
||
+ str(self.V[self.instruction.y]) + ")")
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.i == 0xF: # Multi Case
|
||
if opc.kk == 0x07:
|
||
self.V[self.instruction.x] = self.delay_timer
|
||
self.PC += 2
|
||
print("Set V" + str(self.instruction.x) + " to delay timer (" + str(self.delay_timer) + ")")
|
||
return
|
||
|
||
if opc.kk == 0x15:
|
||
self.delay_timer = self.V[self.instruction.x]
|
||
self.PC += 2
|
||
print("Set delay timer to V" + str(self.instruction.x) + " (" + str(self.delay_timer) + ")")
|
||
return
|
||
|
||
if opc.kk == 0x1E: # FX1E: Set I = I + VX
|
||
self.I = (self.I + self.V[self.instruction.x]) & 0xFFFF
|
||
self.PC += 2
|
||
print("=>Added V" + str(self.instruction.x) + "(" + str(self.V[self.instruction.x])
|
||
+ ") to I. Is now: " + str(hex(self.I)))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.kk == 0x55: # FX55: Copy values of register V0-VX into memory, starting at register I
|
||
for offset in range(0, self.instruction.x + 1):
|
||
self.memory[self.I + offset] = self.V[offset]
|
||
self.PC += 2
|
||
print("=>Stored " + str(self.V[0:self.instruction.x + 1]) + " at " + str(hex(self.I)))
|
||
self.jumps = 0
|
||
return
|
||
|
||
if opc.kk == 0x65: # FX55: Copy values of register V0-VX into memory, starting at register I
|
||
for offset in range(0, self.instruction.x + 1):
|
||
self.V[offset] = self.memory[self.I + offset]
|
||
self.PC += 2
|
||
print("=>Stored " + str(self.V[0:self.instruction.x + 1]) + " from " + str(hex(self.I)))
|
||
self.jumps = 0
|
||
return
|
||
|
||
self.interrupt = True
|
||
return "Unknown Opcode: " + str(hex(self.instruction.op))
|
||
|
||
# TODO: Redo opcodes. Weird stuff happening. Probably typo. Do it carefully this time
|