Initial release.

First milestone! You can have a basic walkthrough experience now!

Signed-off-by: net2cn <mcopener@gmail.com>

Author: net2cn

.gitignore

@@ -2,5 +2,6 @@
 /.VSCodeCounter
 /roms
 /debug
+/release
 go.sum
 __debug_bin

README.md

@@ -4,7 +4,16 @@ Yet another NES emulator written in Golang.
 Currently working in progress.
 
 ## Current status:
-![SMB_Title](./img/screenshot_20200731154145.png)
+CPU and PPU are implemented, as well as the mapper 0. Also, controller 0 is implemented.
+
+But no audio support yet.
+
+![SMB_Title](./img/screenshot_20200731221629.png)
+
+## Usage
+```
+GoNES -file [NES_ROM_file]
+```
 
 Reference: http://wiki.nesdev.com/
 

ui/assets/UbuntuMono-R.ttf assets/UbuntuMono-R.ttfui/assets/UbuntuMono-R.ttf renamed to assets/UbuntuMono-R.ttf

@@ -1,8 +1,11 @@
 package main
 
 import (
+	"flag"
 	"fmt"
+	"log"
 	"os"
+	"runtime/pprof"
 	"sort"
 	"strconv"
 	"time"
@@ -16,13 +19,14 @@ import (
 
 // SDL2 variables
 var windowTitle string = "GoNES SDL2"
-var fontPath string = "./ui/assets/UbuntuMono-R.ttf" // Man, do not use a variable-width font! It looks too ugly with that!
+var fontPath string = "./assets/UbuntuMono-R.ttf" // Man, do not use a variable-width font! It looks too ugly with that!
 var fontSize int = 15
 var windowWidth, windowHeight int32 = 680, 480
 
 // Timer.
 var startTime time.Time = time.Now()
 var endTime time.Time = time.Now()
+var elapsedTime int64 = 0
 
 type debugger struct {
 	bus  *nes.Bus
@@ -267,26 +271,66 @@ func (debug *debugger) Update(elapsedTime int64) bool {
 	// Swap screen and buffer (present),
 	// Clear buffer for next round.
 
-	// Get user inputs.
+	// Get NES controller inputs.
+	keyState := sdl.GetKeyboardState()
+
+	debug.bus.Controller[0] = 0x00
+	if keyState[sdl.SCANCODE_X] != 0 {
+		debug.bus.Controller[0] |= 0x80
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	if keyState[sdl.SCANCODE_Z] != 0 {
+		debug.bus.Controller[0] |= 0x40
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	if keyState[sdl.SCANCODE_A] != 0 {
+		debug.bus.Controller[0] |= 0x20
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	if keyState[sdl.SCANCODE_S] != 0 {
+		debug.bus.Controller[0] |= 0x10
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	if keyState[sdl.SCANCODE_UP] != 0 {
+		debug.bus.Controller[0] |= 0x08
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	if keyState[sdl.SCANCODE_DOWN] != 0 {
+		debug.bus.Controller[0] |= 0x04
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	if keyState[sdl.SCANCODE_LEFT] != 0 {
+		debug.bus.Controller[0] |= 0x02
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	if keyState[sdl.SCANCODE_RIGHT] != 0 {
+		debug.bus.Controller[0] |= 0x01
+	} else {
+		debug.bus.Controller[0] |= 0x00
+	}
+
+	// Get debugger inputs.
 	for event := sdl.PollEvent(); event != nil; event = sdl.PollEvent() {
 		switch t := event.(type) {
 		case *sdl.QuitEvent:
 			return false
 		case *sdl.KeyboardEvent:
 			if !debug.inputLock {
 				switch t.Keysym.Sym {
-				// NES controller
-				// Bugged...
-				case sdl.K_s:
-					debug.bus.Controller[0] |= 0x10
-				case sdl.K_UP:
-					debug.bus.Controller[0] |= 0x08
-				case sdl.K_DOWN:
-					debug.bus.Controller[0] |= 0x04
-				case sdl.K_LEFT:
-					debug.bus.Controller[0] |= 0x02
-				case sdl.K_RIGHT:
-					debug.bus.Controller[0] |= 0x01
 				// Debug utility.
 				case sdl.K_c:
 					// Golang's do while.
@@ -321,8 +365,10 @@ func (debug *debugger) Update(elapsedTime int64) bool {
 
 			// Anti-jittering
 			if t.Repeat > 0 {
+				// Held.
 				debug.inputLock = false
 			} else {
+				// Pressed once.
 				if t.State == sdl.RELEASED {
 					debug.inputLock = false
 				} else if t.State == sdl.PRESSED {
@@ -337,7 +383,7 @@ func (debug *debugger) Update(elapsedTime int64) bool {
 		if debug.residualTime > 0 {
 			debug.residualTime -= elapsedTime
 		} else {
-			debug.residualTime += 1000/60 - elapsedTime
+			debug.residualTime += 1000000/60 - elapsedTime
 			// Golang's do while.
 			for done := true; done; done = debug.bus.PPU.FrameComplete != true {
 				debug.bus.Clock()
@@ -389,18 +435,23 @@ func (debug *debugger) Update(elapsedTime int64) bool {
 	debug.drawDMA(416, 72, 25)
 
 	// Draw key hints.
-	debug.drawString(0, 362, "SPACE - Run/stop", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
-	debug.drawString(0, 372, "R - Reset", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
-	debug.drawString(0, 382, "F - Step one frame", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
-	debug.drawString(0, 392, "C - Step one instruction", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
-	debug.drawString(0, 402, "D - Dump screen", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
-	debug.drawString(0, 412, "P - Change palette", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
-
-	fps := 0
-	if elapsedTime != 0 {
-		fps = int(1000 / elapsedTime)
-	}
-	debug.drawString(612, 2, "FPS: "+strconv.Itoa(fps), &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 306, "NES", &sdl.Color{R: 255, G: 255, B: 0, A: 0})
+	debug.drawString(2, 316, "Z - A", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 326, "X - B", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 336, "A - Select", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 346, "S - Start", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 356, "UP - Up", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 366, "DOWN - Down", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 376, "LEFT - Left", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 386, "RIGHT - Right", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+
+	debug.drawString(2, 406, "Debugger", &sdl.Color{R: 255, G: 255, B: 0, A: 0})
+	debug.drawString(2, 416, "SPACE - Run/stop", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 426, "R - Reset", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 436, "F - Step one frame", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 446, "C - Step one instruction", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 456, "D - Dump screen", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
+	debug.drawString(2, 466, "P - Change palette", &sdl.Color{R: 0, G: 255, B: 0, A: 0})
 
 	// Swap buffer and present our rendered content.
 	debug.window.UpdateSurface()
@@ -414,28 +465,56 @@ func (debug *debugger) Update(elapsedTime int64) bool {
 }
 
 func (debug *debugger) Start() {
-	elapsedTime := startTime.Sub(endTime).Milliseconds()
+	var passedTime int64 = 0
+	var passedFrame int64 = 0
 
 	running := true
 	for running {
 		startTime = time.Now()
 		running = debug.Update(elapsedTime)
 		endTime = time.Now()
-		elapsedTime = endTime.Sub(startTime).Milliseconds()
+		elapsedTime = endTime.Sub(startTime).Microseconds()
+
+		passedTime += elapsedTime
+		passedFrame++
+		if passedTime >= 1000000 {
+			debug.window.SetTitle(windowTitle + " FPS: " + strconv.Itoa(int(1000000/(passedTime/passedFrame))))
+			passedTime = 0
+			passedFrame = 0
+		}
 	}
-
 }
 
 func main() {
 	fmt.Println(windowTitle)
-
 	// I really enjoy its graphics. I mean the anime movie.
 	fmt.Println("HELLO WORLD -ALLTALE-")
 	fmt.Println("With programming we have god's hand.")
 
+	// Read flags
+	var file = flag.String("file", "", "NES ROM file")
+	var cpuprofile = flag.String("cpuprofile", "", "Write cpu profile to file")
+
+	flag.Parse()
+
+	// Handle flags
+	if *file == "" {
+		fmt.Println("Please specify a NES ROM file.")
+		os.Exit(1)
+	}
+
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+
 	// Construct a debugger instance.
 	debug := debugger{}
-	err := debug.Construct("./roms/smb.nes", windowWidth, windowHeight)
+	err := debug.Construct(*file, windowWidth, windowHeight)
 	if err != nil {
 		return
 	}

ui/assets/test.png assets/test.pngui/assets/test.png renamed to assets/test.png

@@ -0,0 +1,81 @@
+NES OAM Stress Test
+-------------------
+Thoroughly tests OAM address ($2003) and read/write ($2004). On an NTSC
+NES, this passes only for one of the four random PPU-CPU
+synchronizations at power/reset. Test takes about 30 seconds, unless it
+fails.
+
+This test randomly sets the address, then randomly either writes a
+random number of random bytes, or reads from the current address a
+random number of times and verifies that it matches what's expected. It
+does this for tens of seconds (refreshing OAM periodically so it doesn't
+fade). Once done, it verifies that all bytes in OAM match what's
+expected.
+
+Expected behavior:
+
+$2003 write sets OAM address.
+
+$2004 write sets byte at current OAM address to byte written, then
+increments OAM address.
+
+$2004 read gives byte at current OAM address, without modifying OAM
+address.
+
+
+Flashes, clicks, other glitches
+-------------------------------
+Some tests might need to turn the screen off and on, or cause slight
+audio clicks. This does not indicate failure, and should be ignored.
+Only the test result reported at the end is important, unless stated
+otherwise.
+
+
+Text output
+-----------
+Tests generally print information on screen. They also output the same
+text as a zero-terminted string beginning at $6004, allowing examination
+of output in an NSF player, or a NES emulator without a working PPU. The
+tests also work properly if the PPU doesn't set the VBL flag properly or
+doesn't implement it at all.
+
+The final result is displayed and also written to $6000. Before the test
+starts, $80 is written there so you can tell when it's done. If a test
+needs the NES to be reset, it writes $81 there (emulator should wait a
+couple of frames after seeing $81). In addition, $DE $B0 $G1 is written
+to $6001-$6003 to allow an emulator to detect when a test is being run,
+as opposed to some other NES program. In NSF builds, the final result is
+also reported via a series of beeps (see below).
+
+See the source code for more information about a particular test and why
+it might be failing. Each test has comments and correct output at the
+top.
+
+
+NSF versions
+------------
+Many NSF-based tests require that the NSF player either not interrupt
+the init routine with the play routine, or if it does, not interrupt the
+play routine again if it hasn't returned yet. This is because many tests
+need to run for a while without returning.
+
+NSF versions also make periodic clicks to avoid the NSF player from
+thinking the track is silent and thus ending the track before it's done
+testing.
+
+In addition to the other text output methods described above, NSF builds
+report essential information bytes audibly, including the final result.
+A byte is reported as a series of tones. The code is in binary, with a
+low tone for 0 and a high tone for 1, and with leading zeroes skipped.
+The first tone is always a zero. A final code of 0 means passed, 1 means
+failure, and 2 or higher indicates a specific reason as listed in the
+source code by the corresponding set_code line. Examples:
+
+Tones         Binary  Decimal  Meaning
+- - - - - - - - - - - - - - - - - - - - 
+low              0      0      passed
+low high        01      1      failed
+low high low   010      2      error 2
+
+-- 
+Shay Green <gblargg@gmail.com>