sketched in savekey support

-savekey argument added to play and debug mode

savekey window available in debug menu

Author: JetSetIlly

README.md

@@ -23,7 +23,7 @@ In addition to the debugger, `Gopher2600` can [record and playback gameplay sess
 
 The gameplay playback feature is also used in the inbuilt [regression database](#regression-database). This database allow for easy testing of the emulator's integrity and was of invaluable use during development of the emulator. This feature will also be of use perhaps when developing new ROMs for the Atari 2600 - a way of recording the ideal output of the ROM for future comparison.
 
-The Atari 2600 comes with a variety of [hand controllers](#hand-controllers) and `Gopher2600` does it's very best to automatically select the correct input device. This is an feature that will be expanded on greatly in the future but currently joysticks, paddles and keyboard are all supported.
+The Atari 2600 comes with a variety of [hand controllers](#hand-controllers) and `Gopher2600` does it's very best to automatically select the correct input device. `Gopher2600` also supports the [SaveKey](#savekey) peripheral.
 
 `Gopher2600` supports a variety of cartridge formats including [Supercharger](#supercharger-roms) from MP3 or WAV files. It supports `DPC+` format although there is no support for the ARM as yet. Most other formats are also supported.
 
@@ -281,6 +281,22 @@ The file can be placed in the current working directory or in the same
 directory as the supercharger ROM being loaded. Alternatively, it can be placed
 in the emulator's [configuration directory](#configuration-directory).
 
+## SaveKey
+
+`Gopher2600` has basic support for the `SaveKey` peripheral. This will be
+expanded on in the future.
+
+For now, the presence of the peripheral must be specified with the `-savekey`
+arugment. This is only available in `play` and `debug` mode. The simplest
+invocation to load a ROM with the `SaveKey` peripheral:
+
+	> gopher2600 -savekey roms/mgd.bin
+
+Note that the `SaveKey` will always be inserted in the second player port.
+
+Data saved to the `SaveKey` will be saved in the [configuration directory](#configuration-directory) to the
+binary file named simply, `savekey`.
+
 ## Recording Gameplay
 
 `Gopher2600` can record all user input and playback for future viewing. This is a very efficient way

debugger/debugger.go

@@ -30,6 +30,8 @@ import (
 	"github.com/jetsetilly/gopher2600/hardware"
 	"github.com/jetsetilly/gopher2600/hardware/cpu/execution"
 	"github.com/jetsetilly/gopher2600/hardware/memory/cartridge/banks"
+	"github.com/jetsetilly/gopher2600/hardware/riot/ports"
+	"github.com/jetsetilly/gopher2600/hardware/riot/ports/savekey"
 	"github.com/jetsetilly/gopher2600/logger"
 	"github.com/jetsetilly/gopher2600/reflection"
 	"github.com/jetsetilly/gopher2600/setup"
@@ -140,7 +142,7 @@ type Debugger struct {
 
 // NewDebugger creates and initialises everything required for a new debugging
 // session. Use the Start() method to actually begin the session.
-func NewDebugger(tv television.Television, scr gui.GUI, term terminal.Terminal) (*Debugger, error) {
+func NewDebugger(tv television.Television, scr gui.GUI, term terminal.Terminal, useSavekey bool) (*Debugger, error) {
 	var err error
 
 	dbg := &Debugger{
@@ -158,6 +160,14 @@ func NewDebugger(tv television.Television, scr gui.GUI, term terminal.Terminal)
 		return nil, errors.New(errors.DebuggerError, err)
 	}
 
+	// replace player 1 port with savekey
+	if useSavekey {
+		err = dbg.VCS.RIOT.Ports.AttachPlayer(ports.Player1ID, savekey.NewSaveKey)
+		if err != nil {
+			return nil, errors.New(errors.DebuggerError, err)
+		}
+	}
+
 	// create a new disassembly instance
 	dbg.Disasm, err = disassembly.NewDisassembly()
 	if err != nil {

debugger/debugger_test.go

@@ -217,7 +217,7 @@ func (trm *mockTerm) testSequence() {
 func TestDebugger_withNonExistantInitScript(t *testing.T) {
 	trm := newMockTerm(t)
 
-	dbg, err := debugger.NewDebugger(&mockTV{}, &mockGUI{}, trm)
+	dbg, err := debugger.NewDebugger(&mockTV{}, &mockGUI{}, trm, false)
 	if err != nil {
 		t.Fatalf(err.Error())
 	}
@@ -233,7 +233,7 @@ func TestDebugger_withNonExistantInitScript(t *testing.T) {
 func TestDebugger(t *testing.T) {
 	trm := newMockTerm(t)
 
-	dbg, err := debugger.NewDebugger(&mockTV{}, &mockGUI{}, trm)
+	dbg, err := debugger.NewDebugger(&mockTV{}, &mockGUI{}, trm, false)
 	if err != nil {
 		t.Fatalf(err.Error())
 	}

gopher2600.go

@@ -241,6 +241,7 @@ func play(md *modalflag.Modes, sync *mainSync) error {
 	patchFile := md.AddString("patch", "", "patch file to apply (cartridge args only)")
 	hiscore := md.AddBool("hiscore", false, "contact hiscore server [EXPERIMENTAL]")
 	log := md.AddBool("log", false, "echo debugging log to stdout")
+	useSavekey := md.AddBool("savekey", false, "use savekey in player 1 port")
 
 	p, err := md.Parse()
 	if err != nil || p != modalflag.ParseContinue {
@@ -313,7 +314,7 @@ func play(md *modalflag.Modes, sync *mainSync) error {
 			}
 		}
 
-		err = playmode.Play(tv, scr, *record, cartload, *patchFile, *hiscore)
+		err = playmode.Play(tv, scr, *record, cartload, *patchFile, *hiscore, *useSavekey)
 		if err != nil {
 			return err
 		}
@@ -348,6 +349,7 @@ func debug(md *modalflag.Modes, sync *mainSync) error {
 	termType := md.AddString("term", "IMGUI", "terminal type to use in debug mode: IMGUI, COLOR, PLAIN")
 	initScript := md.AddString("initscript", defInitScript, "script to run on debugger start")
 	profile := md.AddBool("profile", false, "run debugger through cpu profiler")
+	useSavekey := md.AddBool("savekey", false, "use savekey in player 1 port")
 
 	p, err := md.Parse()
 	if err != nil || p != modalflag.ParseContinue {
@@ -410,7 +412,7 @@ func debug(md *modalflag.Modes, sync *mainSync) error {
 	sync.state <- reqNoIntSig
 
 	// prepare new debugger instance
-	dbg, err := debugger.NewDebugger(tv, scr, term)
+	dbg, err := debugger.NewDebugger(tv, scr, term, *useSavekey)
 	if err != nil {
 		return err
 	}

gui/sdlimgui/lazyvalues/lazy.go

@@ -52,6 +52,7 @@ type Lazy struct {
 	Collisions    *LazyCollisions
 	ChipRegisters *LazyChipRegisters
 	Log           *LazyLog
+	SaveKey       *LazySaveKey
 
 	// \/\/\/ the following are updated on demand rather than through the update
 	// function, because they require more context
@@ -91,6 +92,7 @@ func NewValues() *Lazy {
 	val.Collisions = newLazyCollisions(val)
 	val.ChipRegisters = newLazyChipRegisters(val)
 	val.Log = newLazyLog(val)
+	val.SaveKey = newLazySaveKey(val)
 
 	// allocating enough space for every byte in cartridge space. not worrying
 	// about bank sizes or anything like that.
@@ -144,6 +146,7 @@ func (val *Lazy) Update() {
 	val.Collisions.update()
 	val.ChipRegisters.update()
 	val.Log.update()
+	val.SaveKey.update()
 }
 
 // HasBreak checks to see if disassembly entry has a break point

gui/sdlimgui/lazyvalues/savekey.go

@@ -0,0 +1,57 @@
+// This file is part of Gopher2600.
+//
+// Gopher2600 is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gopher2600 is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gopher2600.  If not, see <https://www.gnu.org/licenses/>.
+
+package lazyvalues
+
+import (
+	"sync/atomic"
+
+	"github.com/jetsetilly/gopher2600/hardware/riot/ports/savekey"
+)
+
+// LazyChipRegisters lazily accesses chip registere information from the emulator
+type LazySaveKey struct {
+	val *Lazy
+
+	SaveKeyActive bool
+
+	atomicSDA atomic.Value // []float32
+	atomicSCL atomic.Value // []float32
+	SDA       []float32
+	SCL       []float32
+}
+
+func newLazySaveKey(val *Lazy) *LazySaveKey {
+	return &LazySaveKey{val: val}
+}
+
+func (lz *LazySaveKey) update() {
+	lz.val.Dbg.PushRawEvent(func() {
+		if l, ok := lz.val.Dbg.VCS.RIOT.Ports.Player1.(*savekey.SaveKey); ok {
+			lz.atomicSDA.Store(l.SDA.Copy())
+			lz.atomicSCL.Store(l.SCL.Copy())
+		}
+	})
+
+	if l, ok := lz.atomicSDA.Load().([]float32); ok {
+		lz.SaveKeyActive = ok
+		lz.SDA = l
+	}
+
+	if l, ok := lz.atomicSCL.Load().([]float32); ok {
+		lz.SaveKeyActive = ok
+		lz.SCL = l
+	}
+}

gui/sdlimgui/win_savekey.go

@@ -0,0 +1,71 @@
+// This file is part of Gopher2600.
+//
+// Gopher2600 is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Gopher2600 is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Gopher2600.  If not, see <https://www.gnu.org/licenses/>.
+
+package sdlimgui
+
+import (
+	"github.com/inkyblackness/imgui-go/v2"
+	"github.com/jetsetilly/gopher2600/hardware/riot/ports/savekey"
+)
+
+const winSaveKeyTitle = "SaveKey (work in progress)"
+
+type winSaveKey struct {
+	windowManagement
+	widgetDimensions
+
+	img *SdlImgui
+}
+
+func newWinSaveKey(img *SdlImgui) (managedWindow, error) {
+	win := &winSaveKey{
+		img: img,
+	}
+
+	return win, nil
+}
+
+func (win *winSaveKey) init() {
+	win.widgetDimensions.init()
+}
+
+func (win *winSaveKey) destroy() {
+}
+
+func (win *winSaveKey) id() string {
+	return winSaveKeyTitle
+}
+
+func (win *winSaveKey) draw() {
+	if !win.open {
+		return
+	}
+
+	imgui.SetNextWindowPosV(imgui.Vec2{633, 358}, imgui.ConditionFirstUseEver, imgui.Vec2{0, 0})
+	imgui.BeginV(winSaveKeyTitle, &win.open, imgui.WindowFlagsAlwaysAutoResize)
+
+	// oscilloscope
+	imgui.PushStyleColor(imgui.StyleColorFrameBg, win.img.cols.AudioOscBg)
+
+	imgui.PushStyleColor(imgui.StyleColorPlotLines, imgui.Vec4{1.0, 0.0, 0.0, 1.0})
+	imgui.PlotLinesV("", win.img.lz.SaveKey.SCL, 0, "SCL", savekey.TraceLo, savekey.TraceHi, imgui.Vec2{X: 512, Y: imgui.FrameHeight() * 2})
+
+	imgui.PushStyleColor(imgui.StyleColorPlotLines, imgui.Vec4{0.0, 1.0, 0.0, 1.0})
+	imgui.PlotLinesV("", win.img.lz.SaveKey.SDA, 0, "SDA", savekey.TraceLo, savekey.TraceHi, imgui.Vec2{X: 512, Y: imgui.FrameHeight() * 2})
+
+	imgui.PopStyleColorV(3)
+
+	imgui.End()
+}

gui/sdlimgui/windowmanager.go

@@ -66,9 +66,10 @@ type windowManager struct {
 
 // the window menus grouped by type. the types are:
 const (
-	windowMenuDebugger = "Debugger"
-	windowMenuVCS      = "VCS"
-	windowMenuCart     = "Cartridge"
+	windowMenuDebugger    = "Debugger"
+	windowMenuVCS         = "VCS"
+	windowMenuCart        = "Cartridge"
+	windowMenuPeripherals = "Peripherals"
 
 	// additional window menus are grouped by cartridge type
 )
@@ -165,6 +166,9 @@ func newWindowManager(img *SdlImgui) (*windowManager, error) {
 	if err := addWindow(newWinCartTape, false, windowMenuCart); err != nil {
 		return nil, err
 	}
+	if err := addWindow(newWinSaveKey, false, windowMenuPeripherals); err != nil {
+		return nil, err
+	}
 
 	// associate cartridge types with cartridge specific menus. using cartridge
 	// ID as the key in the windowMenu map
@@ -289,6 +293,15 @@ func (wm *windowManager) drawMenu() {
 		}
 	}
 
+	// add savekey specific menu
+	if wm.img.lz.SaveKey.SaveKeyActive {
+		if imgui.BeginMenu("SaveKey") {
+			wm.drawMenuWindowEntry(wm.windows[winSaveKeyTitle], winSaveKeyTitle)
+			imgui.EndMenu()
+		}
+	}
+
+	// filename in titlebar
 	imgui.SameLineV(imgui.WindowWidth()-imguiGetFrameDim(wm.img.lz.Cart.Filename).X-20.0, 0.0)
 	imgui.Text(wm.img.lz.Cart.Filename)
 

hardware/riot/ports/peripherals.go

@@ -31,6 +31,19 @@ const (
 	PanelID
 )
 
+func (id *PortID) String() string {
+	switch *id {
+	case Player0ID:
+		return "player 0"
+	case Player1ID:
+		return "player 1"
+	case PanelID:
+		return "panel"
+	}
+
+	return "not attached"
+}
+
 // Peripheral represents a (input or output) device that can attached to the
 // VCS ports.
 type Peripheral interface {