I’ve made good progress with my RetroChallenge to get an NES controller working on my RC2014 computer.
I wanted to be able to play a game with the controller. I had hoped to write my own, but with only a few days left, I didn’t think this was practical. Instead, I wondered about hacking an existing game.
While it’s not an RC2014, the Sinclair ZX Spectrum is also based on the Z80 processor. Colin Piggot makes a ZX Spectrum Bus Interface that allows RC2014 cards to be plugged into a Speccy.
As the RC2014 NES controller module can now be plugged into a Speccy, could I adapt one of my favourite games to work with it? Could Manic Miner be playable with an NES controller?
The first step was to try to disassemble Manic Miner to see how the existing Kempston joystick support worked. I was hoping it would be simple to just wire in NES controller support there.
I made a start on this myself, before thinking that for such an iconic game, someone must have done this before. A quick search revealed an excellent commented disassembly of Manic Miner by Richard Dymond.
Faking a Kempston joystick
The Kempston joystick interface works by using a Z80 in operation on port 31. I would need to fake this by calling a routine to read the NES controller and return data in the Kempston format.
The Kempston joysticker interface returns the following in a single byte.
| Bit | Value |
| 0 | Right |
| 1 | Left |
| 2 | Down |
| 3 | Up |
| 4 | Fire |
| 5 | N/A |
| 6 | N/A |
| 7 | N/A |
So, if the Fire button is being pressed, bit 4 will be 1.
I can modify the get_buttons routine I previously wrote to read the NES controller and return the data in this format.
To do this, before the pop bc instruction, I can add the following code.
; build the kempston joystick byte in register a
xor a ; clear a
.test_fire:
bit NES_A_BTN, c
jr nz, .test_up
set 4, a
.test_up:
bit NES_UP_BTN, c
jr nz, .test_down
set 3, a
.test_down:
bit NES_DOWN_BTN, c
jr nz, .test_left
set 2, a
.test_left:
bit NES_LEFT_BTN, c
jr nz, .test_right
set 1, a
.test_right:
bit NES_RIGHT_BTN, c
jr nz, .done
set 0, a
.done:
pop bc ; restore bc registersHere I am clearing the a register so all bits have a default value of 0. Next, I am testing the bits in the byte I built to store the values from the NES controller. If the bits are set in the NES byte, then I set the relevant bit in the Kempston byte.
Hacking Manic Miner
My original idea was to load Manic Miner into a Spectrum, then use a Multiface to poke my changes into memory. Although this would work, I decided it would take too long and would be harder to save my work.
Instead, I downloaded a clean .tap file of Manic Miner from World of Spectrum and loaded this into the ZEsarUX emulator. ZEsarUX will let me poke my changes into the game and save the results as an SNA file. I can use the SNA file on a DivMMC connected to my Spectrum to load the game. This means I can make sure the game is still working before saving my changes.
I needed to find a place to store my get_buttons routine in Manic Miner. Upon examining the disassembly, remnants of the source code from when Matthew Smith was writing the game are visible at 0x934c. This space is unused in the game, so it’s safe for me to put my code there.
; A simple button reading program for the RC2014 Z80 computer running SCM
; This will pretend to be a Kempston joystick interface, and return bits like that interface.
; Robert Price - 24th October 2025
ORG $934c
; The Z80 port address to use for the controller interface.
NES_PORT EQU $01
; The bit masks for the controller interface lines.
CLOCK EQU $01
LATCH EQU $02
DATA EQU $01
NES_A_BTN EQU $00
NES_UP_BTN EQU $04
NES_DOWN_BTN EQU $05
NES_LEFT_BTN EQU $06
NES_RIGHT_BTN EQU $07
; subroutine to read the NES controller button states.
; returns the button states in register a.
; all other registers are preserved.
get_buttons:
push bc ; save bc registers
; pulse the LATCH line low to high and back to low again.
xor a ; set a to 0
out (NES_PORT), a
ld a, LATCH
out (NES_PORT), a
xor a ; set a to 0
out (NES_PORT), a
; setup the loop counter to read 8 buttons.
ld b, 8 ; 8 buttons to read. This will be decremented to 0.
; now we rebuild the byte into register c. As we are setting all 8 bits,
; we don't need to worry about clearing c first.
.loop:
; read the controller button states
in a, (NES_PORT) ; read the DATA line
; move the DATA bit into register c to rebuild the send byte
srl a ; shift right to get the DATA bit into carry
rr c ; rotate carry into bit 7 of c
; pulse the CLOCK line to read the next button.
ld a, CLOCK
out (NES_PORT), a
xor a ; set a to 0
out (NES_PORT), a
; loop 8 times to read all buttons.
djnz .loop
; build the kempston joystick byte in register a
xor a ; clear a
.test_fire:
bit NES_A_BTN, c
jr nz, .test_up
set 4, a
.test_up:
bit NES_UP_BTN, c
jr nz, .test_down
set 3, a
.test_down:
bit NES_DOWN_BTN, c
jr nz, .test_left
set 2, a
.test_left:
bit NES_LEFT_BTN, c
jr nz, .test_right
set 1, a
.test_right:
bit NES_RIGHT_BTN, c
jr nz, .done
set 0, a
.done:
pop bc ; restore bc registers
ret ; return to caller with button states in a
I compiled the code using the sjasmplus assembler on my Mac, and this gave me a 61-byte block of assembled code. Running this through hexdump gave me the following hex code to poke into memory.
9c4c c5 af d3 01 3e 02 d3 01 af d3 01 06 08 db 01 cb
9c5c 3f cb 19 3e 01 d3 01 af d3 01 10 f1 af cb 41 20
9c6c 02 cb e7 cb 61 20 02 cb df cb 69 20 02 cb d7 cb
9c7c 71 20 02 cb cf cb 79 20 02 cb c7 c1 c9I used the Hexadecimal Editor in the Debug Menu of ZEsarUX to input this.
Now I needed to call this when the Kempston joystick was being called from the game.
The first place this is done is at address 0x8878. This code checks if the fire button is being pressed in demo mode.
8878 LD A,($8459) Pick up the Kempston joystick indicator from 8459
887B OR A Is there a joystick connected?
887C JR Z,$8884 Jump if not
887E IN A,($1F) Collect input from the joystickIn this case, I don’t need to check the joystick indicator, so all 4 instructions can be replaced with the following.
8878 CALL $934C
887B NOP
887C NOP
887D NOP
887E NOP
887F NOPThe NOP instructions tell the Z80 to do nothing. I am just using them to fill up the space that the 4 original instructions were using. The assembled code looks like this, and it was loaded using the hexadecimal editor.
8878 cd 4c 93 00 00 00 00 00The next block of code looks for left or right being pressed at address 0x8C24
8C24 LD A,($8459) Collect the Kempston joystick indicator from 8459
8C27 OR A Is the joystick connected?
8C28 JR Z,$8C34 Jump if not
8C2A LD BC,$001F Collect input from the joystick
8C2D IN A,(C)I can use the same code as before to drop in there, but I need an extra 3 NOP instructions to fill up the space. The replacement hex code looks like this.
8C24 cd 4c 93 00 00 00 00 00 00 00 00There is similar code to check the fire button at address 0x8c6c. I can poke in the same hex code there.
8C6C cd 4c 93 00 00 00 00 00 00 00 00Finally, there is a routine at 0x9337 that checks if the fire button is being pressed. This is a shorter version like the code at 0x8878, so I can poke in the same code there.
9337 cd 4c 93 00 00 00 00 00I can now save a snapshot of the game. I do this using the Snapshot option in ZEsarUX and making sure I use a .SNA file extension. I called my file MMNES.SNA. It’s available to download for anyone following along.
Copying this to an SD card and placing it in the DivMMC allowed me to load the modified game on my Spectrum.
Conclusion
While I hadn’t planned to hack a Spectrum game as part of the RetroChallenge this year, it’s turned out to be a great diversion and learning experience. It’s still using the code and hardware developed on the RC2014.
The joypad works well, and although it is using a little more CPU time, it’s not noticeable when playing the game. It doesn’t have the nostalgia value of using the Spectrum’s rubber keys, but it is responsive and comfortable to use.
