main.py

import pygame
import sys
import random

SELECTED_FILE = "Pong (1 player).ch8"

MEMORY_SIZE = 4096 # 4KB of RAM
DISPLAY_WIDTH = 64
DISPLAY_HEIGHT = 32
NUMBER_REGISTERS = 16
STACK_SIZE = 16
NUMBER_OF_KEYS = 16
START_ADDRESS = 0x200

SCALE = 10 # change this to scale your display. a pure 64x32 pixel display is soooooo little
CYCLES_PER_FRAME = 10

FONTS = [
    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
]

# thanks claude for this list
KEY_MAP = {
    pygame.K_1: 0x1, pygame.K_2: 0x2, pygame.K_3: 0x3, pygame.K_4: 0xC,
    pygame.K_q: 0x4, pygame.K_w: 0x5, pygame.K_e: 0x6, pygame.K_r: 0xD,
    pygame.K_a: 0x7, pygame.K_s: 0x8, pygame.K_d: 0x9, pygame.K_f: 0xE,
    pygame.K_z: 0xA, pygame.K_x: 0x0, pygame.K_c: 0xB, pygame.K_v: 0xF,
}

######################################
#           CHIP-8 CLASS             #
######################################

class CHIP8:
    def __init__(self):
        self.memory = [0] * MEMORY_SIZE
        self.registers = [0] * NUMBER_REGISTERS
        self.stack = [0] * STACK_SIZE
        self.keys = [0] * NUMBER_OF_KEYS

        self.display = [[0] * DISPLAY_WIDTH for i in range(DISPLAY_HEIGHT)] # 64x32 by default

        self.program_counter = START_ADDRESS
        self.index_register = 0
        self.stack_pointer = 0
        self.delay_timer = 0
        self.sound_timer = 0

        self.LOAD_FONTS()

    def LOAD_FILE(self, filename):
        with open(filename, "rb") as FILE:
            data = FILE.read()
            for i, BYTE in enumerate(data): self.memory[START_ADDRESS + i] = BYTE

    def LOAD_FONTS(self):
        for i, BYTE in enumerate(FONTS): self.memory[0x50+i] = BYTE

    def RUN_CYCLE(self):
        opcode = (self.memory[self.program_counter] << 8) | self.memory[self.program_counter +1]
        self.program_counter += 2 # basically advancing counter by 2 bytes immediately that way emulator doesnt keep repeating the same instructions

        #This is instructions on extracting opcode basically
        nibble, x, y, n, nn, nnn = (opcode & 0xF000) >> 12, (opcode & 0x0F00) >> 8, (opcode & 0x00f0) >> 4, (opcode & 0x000F), (opcode & 0x00FF), (opcode & 0x0FFF)

        #############################################################
        # WARNING: HUGE CHUNK OF CLAUDE GENERATED OP CODE INCOMING. #
        #############################################################

        if nibble == 0x0:
            if nn == 0xE0:
                self.display = [[0] * DISPLAY_WIDTH for _ in range(DISPLAY_HEIGHT)]
            elif nn == 0xEE:
                self.stack_pointer -= 1
                self.program_counter = self.stack[self.stack_pointer]

        elif nibble == 0x1:
            self.program_counter = nnn

        elif nibble == 0x2:
            self.stack[self.stack_pointer] = self.program_counter
            self.stack_pointer += 1
            self.program_counter = nnn

        elif nibble == 0x3:
            if self.registers[x] == nn:
                self.program_counter += 2

        elif nibble == 0x4:
            if self.registers[x] != nn:
                self.program_counter += 2

        elif nibble == 0x5:
            if self.registers[x] == self.registers[y]:
                self.program_counter += 2

        elif nibble == 0x6:
            self.registers[x] = nn

        elif nibble == 0x7:
            self.registers[x] = (self.registers[x] + nn) & 0xFF

        elif nibble == 0x8:
            if n == 0x0:
                self.registers[x] = self.registers[y]
            elif n == 0x1:
                self.registers[x] |= self.registers[y]
            elif n == 0x2:
                self.registers[x] &= self.registers[y]
            elif n == 0x3:
                self.registers[x] ^= self.registers[y]
            elif n == 0x4:
                total = self.registers[x] + self.registers[y]
                self.registers[0xF] = 1 if total > 255 else 0
                self.registers[x] = total & 0xFF
            elif n == 0x5:
                self.registers[0xF] = 1 if self.registers[x] > self.registers[y] else 0
                self.registers[x] = (self.registers[x] - self.registers[y]) & 0xFF
            elif n == 0x6:
                self.registers[0xF] = self.registers[x] & 0x1
                self.registers[x] >>= 1
            elif n == 0x7:
                self.registers[0xF] = 1 if self.registers[y] > self.registers[x] else 0
                self.registers[x] = (self.registers[y] - self.registers[x]) & 0xFF
            elif n == 0xE:
                self.registers[0xF] = (self.registers[x] >> 7) & 0x1
                self.registers[x] = (self.registers[x] << 1) & 0xFF

        elif nibble == 0x9:
            if self.registers[x] != self.registers[y]:
                self.program_counter += 2

        elif nibble == 0xA:
            self.index_register = nnn

        elif nibble == 0xB:
            self.program_counter = nnn + self.registers[0]

        elif nibble == 0xC:
            self.registers[x] = random.randint(0, 255) & nn

        elif nibble == 0xD:
            # hey i wrote this part in here btw
            X_POS = self.registers[x] % 64
            Y_POS = self.registers[y] % 32

            self.registers[0xF] = 0

            for i in range(n):
                byte = self.memory[self.index_register + i]
                for j in range(8):
                    if byte & (0x80 >> j):
                        if(Y_POS + i) < DISPLAY_HEIGHT and (X_POS + j) < DISPLAY_WIDTH:
                            if self.display[Y_POS + i][X_POS + j]: self.registers[0xF] = 1
                            self.display[Y_POS + i][X_POS + j] ^= 1

        elif nibble == 0xE:
            if nn == 0x9E:
                if self.keys[self.registers[x]]:
                    self.program_counter += 2
            elif nn == 0xA1:
                if not self.keys[self.registers[x]]:
                    self.program_counter += 2

        elif nibble == 0xF:
            if nn == 0x07:
                self.registers[x] = self.delay_timer
            elif nn == 0x15:
                self.delay_timer = self.registers[x]
            elif nn == 0x18:
                self.sound_timer = self.registers[x]
            elif nn == 0x1E:
                self.index_register += self.registers[x]
            elif nn == 0x0A:
                pressed = False
                for i in range(NUMBER_OF_KEYS):
                    if self.keys[i]:
                        self.registers[x] = i
                        pressed = True
                        break
                if not pressed:
                    self.program_counter -= 2  # rewind and try again next cycle
            elif nn == 0x29:
                self.index_register = 0x50 + (self.registers[x] * 5)
            elif nn == 0x33:
                self.memory[self.index_register]     = self.registers[x] // 100
                self.memory[self.index_register + 1] = (self.registers[x] // 10) % 10
                self.memory[self.index_register + 2] = self.registers[x] % 10
            elif nn == 0x55:
                for i in range(x + 1):
                    self.memory[self.index_register + i] = self.registers[i]
            elif nn == 0x65:
                for i in range(x + 1):
                    self.registers[i] = self.memory[self.index_register + i]
        
        #################################
        #        END OF CLAUDE STUFF    #
        #################################

        if self.delay_timer > 0: self.delay_timer-=1
        if self.sound_timer > 0: self.sound_timer-=1

emulator = CHIP8()
emulator.LOAD_FILE(SELECTED_FILE)

######################################
#           PYGAME STUFF             #
######################################

pygame.init()
screen = pygame.display.set_mode((DISPLAY_WIDTH * SCALE, DISPLAY_HEIGHT * SCALE))
pygame.display.set_caption("CHIP-8 Emulator by Samuel Saylor")
WHITE = (255,255,255)
BLACK = (0,0,0)
clock = pygame.time.Clock()

def HANDLE_INPUT():
    keys = pygame.key.get_pressed()
    for i, j in KEY_MAP.items():
        emulator.keys[j] = 1 if keys[i] else 0

def RENDER_DISPLAY():
    for i in range(DISPLAY_HEIGHT):
        for j in range(DISPLAY_WIDTH):
            if emulator.display[i][j]:
                pygame.draw.rect(screen, WHITE, (j*SCALE,i*SCALE,SCALE,SCALE))

RUNNING = True
while RUNNING:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: RUNNING = False

    for _ in range(CYCLES_PER_FRAME): emulator.RUN_CYCLE()

    HANDLE_INPUT()
    screen.fill(BLACK)
    RENDER_DISPLAY()
    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()