Godot 4 chip-8 emulator not displaying font appropriately

I am making an emulator for the chip-8 utilizing the Godot 4.3 recreation engine, It is virtually full and you may play pong on it completely effective, However it could possibly’t show numbers from the inbuilt font.

Every character is 4 pixels huge and 5 pixels excessive. The character 0 has the encoding 0xF0, 0x90, 0x90, 0x90, 0xF0 which is interpreted as follows:

Here is my font as packed byte array:

# RAM
var RAM: PackedByteArray = []

# Inbuilt font:
var font: PackedByteArray = [
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
]

func _ready() -> void:
    # Different code...

    # Load font into RAM:
    var offset: int = 0x50
    for i: int in font:
        RAM[offset] = i
        offset += 1

    var rom: PackedByteArray = open_read_and_get_ROM("rom_path_here") 
    load_rom_into_ram(rom)

func load_rom_into_ram(ROM: PackedByteArray) -> void:
    var offset: int = 0x200
    for i: int in ROM:
        RAM[offset] = i
        offset += 1

chip-8 roms are supposed to make use of the font that is already inbuilt to your emulator, However the roms I strive show nonsense as an alternative of displaying precise hex numbers.

I actually do not assume there’s something fallacious with the draw instruction as a result of It could actually draw anything completely however right here it’s anyway:

        0xD000: # 1st nibble is 'D':
            # DXYN: Attracts a sprite at coordinate (VX, VY)...
            registers[0xF] = 0 # VF register have to be cleared first.
            var x_pos: int = registers[opcode >> 8 & 0xF] % 64
            var y_pos: int = registers[opcode >> 4 & 0xF] % 32
            for N: int in vary(opcode & 0x000F):
                var Nth_byte: int = RAM[index_register + N]
                for i: int in vary(8):
                    if x_pos >= 64: x_pos = x_pos % 64 # wrap coordinates when reaching finish of display screen.
                    display screen[x_pos][y_pos] = display screen[x_pos][y_pos] ^ (Nth_byte = 32: y_pos = y_pos % 32 # wrap coordinates when reaching finish of display screen.
                queue_redraw()

My emulator:


Anticipated outcome: