Debugger improvements (#26)

* Refactor `DebuggerViewModel` and related classes: Simplify breakpoint management, update `IEmulatorMemory` visibility, and streamline debugging configuration.

* Add Debugger UI improvements: Enable breakpoint toggling, restructure menu, and enhance debugging logic.

* Refactor pause/resume logic: Introduce `ResumeFromDebugMessage` and `PauseForDebugMessage`, adjust `DebuggerViewModel` and `MainWindowViewModel` to improve debugging flow consistency.

* Refactor breakpoint handling and emulator reset logic: Improve breakpoint event subscription, update dialog handling for debugger views, and streamline emulator initialization and debugging configuration.

* Formatting

* Update C# naming abbreviations in `.DotSettings`

* Better breakpoint handling

* Update readme

* Update readme

* Fix link

* Rename

* Typo

* Update readme

* Improve breakpoint handling and create a base breakpoint class for future memory breakpoints

* Enhance breakpoint manager: refactor breakpoint handling logic, introduce `Condition` property, and update number format settings.

* Refactor breakpoint handling, implement memory breakpoints

* Refactor breakpoint handling

* Refactor debugger breakpoint handling

Author: voytas

README.md

@@ -4,21 +4,38 @@
 My own ZX Spectrum emulator written in C# and Avalonia UI. It emulates classic ZX Spectrum 16K, 48K and 
 128K computers.
 
-This is work in progress, I've been improving it quite a lot recently. However it is stable and usable. 
-It can run most of the games and demos without any problems.
+It is quite accurate and stable, it can run most of the games and demos without any issues, load protected
+tapes.
 
-It's a cross-platform emulator that runs on Windows, Linux and macOS. Developed on macOS, so mostly tested
-on this platform. Needs some more testing on Linux.
+It's a cross-platform emulator that runs on Windows, Linux and macOS. Developed on macOS, so generally tested
+on this platform. Needs some more testing on Linux, seems to be running fine on Windows.
 
-This is my hobby project which I always wanted to do. It has been a lot of fun, and quite challenging, too.
-ZX Spectrum was my first computer and I love it. I am planning to keep it alive since I created it for my own 
-use and I am using it to play games and demos.
+This is my hobby project which I always wanted to do. It has been a lot of fun, and quite a challenge.
+There are other emulators out there, but my focus was on making it better structured, easier to understand.
+It is written all by hand, no AI generated code.
+
+ZX Spectrum was my first computer and I still love it. I am planning to keep this project alive since 
+I have created it for my personal use to play games and demos. It is a lot of fun.
 
 It uses several of my own libraries that I created for this project:
-- [Z80 CPU emulator](https://github.com/oldbit-com/Z80/tree/spectron)
-- [File format handling](https://github.com/oldbit-com/Spectron.Files)
-- [Audio player](https://github.com/oldbit-com/Beep)
-- [Gamepad support](https://github.com/oldbit-com/Joypad)
+
+| Library                                                | Description                                  |
+|--------------------------------------------------------|----------------------------------------------|
+| [Z80](https://github.com/oldbit-com/Z80/tree/spectron) | Generic Z80 CPU emulator                     |
+| [Files](https://github.com/oldbit-com/Spectron.Files)  | Handles TZX, Z80, SNA and other file formats |
+| [Beep](https://github.com/oldbit-com/Beep)             | Basic audio player, cross-platform, native   |
+| [Joypad](https://github.com/oldbit-com/Joypad)         | Gamepad handler, cross-platform, native      |
+
+Solution consists of several projects:
+
+| Project                | Description                                            |
+|------------------------|--------------------------------------------------------|
+| Spectron               | Avalonia based UI                                      |
+| Spectron.Debugger      | Fully featured Code debugger, includes UI and controls |
+| Spectron.Disassembly   | Simple Z80 disassembler, used by the debugger          |
+| **Spectron.Emulation** | This is the core of the emulator, e.g. the main thing  |
+| Spectron.Recorder      | Audio and Video recording helper                       |
+
 
 ![Main Window](docs/default.png?raw=true "Main Window")
 
@@ -153,9 +170,9 @@ done in the background by converting static frames to a video stream with audio,
 
 ## Debugger
 Debugger is available in the emulator. It is a simple debugger that allows you to inspect the CPU registers, 
-memory and disassembly. You can step through the code, set breakpoints. This is still work in progress.
+memory and disassembly. You can step through the code, set breakpoints.
 
-### Commands
+### Shortcuts
 - **Step Over** - `F10` \
   For `CALL`, `JR cc`, `JP cc`, `DJNZ`, `LDIR` or `LDDR` instructions, debugger will try to step over the subroutine.
 - **Step Into** - `F11` \
@@ -164,6 +181,19 @@ memory and disassembly. You can step through the code, set breakpoints. This is
   Debugger will step out of the subroutine using the current return address on the stack. 
   So this will only work if the value on the stack contains return address.
 
+### Breakpoints
+
+Two types of breakpoints are supported: on register value change or on memory write
+
+#### Register breakpoints
+Typical scenario is use a condition for PC register, for example `PC==32768`. This would break execution
+at the specified address. However any register can be used, for example `HL==16384`, `A==0x79`etc. 
+
+#### Memory breakpoints
+Memory breakpoints can have two forms: trigger when specific value is written to e memory cell or more generic
+when memory cell is written. For example `16384==32` will break when value `32` has been written to `16384` memory address.
+If condition is just `16384`, execution will break when any value  has been written to that address.
+
 ### Immediate window instructions, case insensitive:
 - `HELP` - print help information
 - `PRINT [expression]` or `? [expression]` - prints a value of the expression
@@ -205,5 +235,4 @@ memory and disassembly. You can step through the code, set breakpoints. This is
 - [Material Icons](https://github.com/SKProCH/Material.Icons)
 - [ZX Spectrum Font](https://github.com/comptic/zx-spectrum-font)
 - [Hack Font](https://sourcefoundry.org/hack/)
-- [VT220 Font](https://github.com/svofski/glasstty/blob/master/Glass_TTY_VT220.ttf)
-
+- [VT220 Font](https://github.com/svofski/glasstty/blob/master/Glass_TTY_VT220.ttf)

Spectron.sln.DotSettings

@@ -9,7 +9,11 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IFF/@EntryIndexedValue">IFF</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IM/@EntryIndexedValue">IM</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IX/@EntryIndexedValue">IX</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IXH/@EntryIndexedValue">IXH</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IXL/@EntryIndexedValue">IXL</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IY/@EntryIndexedValue">IY</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IYH/@EntryIndexedValue">IYH</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IYL/@EntryIndexedValue">IYL</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MAPRAM/@EntryIndexedValue">MAPRAM</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=PC/@EntryIndexedValue">PC</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=SP/@EntryIndexedValue">SP</s:String>

src/Spectron.Debugger/Breakpoints/Breakpoint.cs

@@ -1,18 +1,8 @@
 namespace OldBit.Spectron.Debugger.Breakpoints;
 
-public class Breakpoint(Register register, int value)
+public abstract class Breakpoint
 {
-    public Guid Id { get; } = Guid.NewGuid();
-
     public bool IsEnabled { get; set; } = true;
 
-    public int Value { get; set; } = value;
-
-    public Register Register { get; set; } = register;
-
-    public int? ValueAtLastHit { get; set; } = value;
-
-    public bool ShouldRemoveOnHit { get; set; } = false;
-
-    public override string ToString() => $"{Register} == ${Value:X4}";
+    public string Condition { get; init; } = string.Empty;
 }

src/Spectron.Debugger/Breakpoints/BreakpointHandler.cs

@@ -1,39 +1,114 @@
-using OldBit.Z80Cpu;
-using OldBit.Z80Cpu.Events;
+using OldBit.Spectron.Emulation;
 
 namespace OldBit.Spectron.Debugger.Breakpoints;
 
+public class BreakpointHitEventArgs(Word previousAddress) : EventArgs
+{
+    public Word PreviousAddress { get; } = previousAddress;
+}
+
 public class BreakpointHandler : IDisposable
 {
-    private readonly BreakpointManager _breakpointManager;
-    private readonly Z80 _cpu;
+    private Emulator _emulator;
+    private bool _isEnabled;
+    private Word _previousAddress;
+    private Word _currentAddress;
+
+    public BreakpointManager BreakpointManager { get; }
+
+    public Word PreviousAddress { get; private set; }
+
+    public bool IsBreakpointHit { get; private set; }
+
+    public bool IsEnabled
+    {
+        get => _isEnabled;
+        set
+        {
+            _isEnabled = value;
+            HandleIsEnabled();
+        }
+    }
 
-    public event EventHandler<EventArgs>? BreakpointHit;
+    public event EventHandler<BreakpointHitEventArgs>? BreakpointHit;
 
-    public BreakpointHandler(BreakpointManager breakpointManager, Z80 cpu)
+    public BreakpointHandler(Emulator emulator)
     {
-        _breakpointManager = breakpointManager;
-        _cpu = cpu;
+        _emulator = emulator;
 
-        _cpu.BeforeInstruction += BeforeInstruction;
+        BreakpointManager = new BreakpointManager(emulator.Cpu);
+
+        SubscribeToEvents();
+    }
+
+    public void Update(Emulator emulator)
+    {
+        UnsubscribeFromEvents();
+        SubscribeToEvents();
+
+        BreakpointManager.Update(emulator.Cpu);
+
+        _emulator = emulator;
     }
 
-    private void BeforeInstruction(BeforeInstructionEventArgs e)
+    private void BeforeInstruction(Word pc)
     {
-        if (!_breakpointManager.CheckHit())
+        _previousAddress = _currentAddress;
+        _currentAddress = pc;
+
+        IsBreakpointHit = BreakpointManager.IsRegisterBreakpointHit();
+
+        if (!IsBreakpointHit)
         {
+            PreviousAddress = pc;
             return;
         }
 
-        e.IsBreakpoint = true;
+        _emulator.Break();
+
+        BreakpointHit?.Invoke(this, new BreakpointHitEventArgs(_previousAddress));
+    }
 
-        BreakpointHit?.Invoke(this, EventArgs.Empty);
+    private void MemoryOnMemoryUpdated(Word address)
+    {
+        IsBreakpointHit = BreakpointManager.IsMemoryBreakpointHit(address, _emulator.Memory);
+
+        if (!IsBreakpointHit)
+        {
+            return;
+        }
+
+        _emulator.Break();
+
+        BreakpointHit?.Invoke(this, new BreakpointHitEventArgs(_currentAddress));
+    }
+
+    private void HandleIsEnabled()
+    {
+        UnsubscribeFromEvents();
+
+        if (IsEnabled)
+        {
+            SubscribeToEvents();
+        }
+    }
+
+    private void SubscribeToEvents()
+    {
+        _emulator.Cpu.BeforeInstruction += BeforeInstruction;
+        _emulator.Memory.MemoryUpdated += MemoryOnMemoryUpdated;
+    }
+
+    private void UnsubscribeFromEvents()
+    {
+        _emulator.Cpu.BeforeInstruction -= BeforeInstruction;
+        _emulator.Memory.MemoryUpdated -= MemoryOnMemoryUpdated;
     }
 
     public void Dispose()
     {
         GC.SuppressFinalize(this);
 
-        _cpu.BeforeInstruction -= BeforeInstruction;
+        UnsubscribeFromEvents();
     }
 }

src/Spectron.Debugger/Breakpoints/BreakpointList.cs

@@ -0,0 +1,52 @@
+namespace OldBit.Spectron.Debugger.Breakpoints;
+
+public sealed class BreakpointList
+{
+    private readonly List<Breakpoint> _breakpoints = [];
+
+    public IReadOnlyList<Breakpoint> Breakpoints => _breakpoints;
+    public IReadOnlyList<RegisterBreakpoint> Register { get; private set; } = [];
+    public IReadOnlyList<MemoryBreakpoint> Memory { get; private set; } = [];
+
+    public void Add(Breakpoint breakpoint)
+    {
+        _breakpoints.Add(breakpoint);
+
+        SynchronizeLists();
+    }
+
+    public void AddIfNotExists(Breakpoint breakpoint)
+    {
+        if (!_breakpoints.Contains(breakpoint))
+        {
+            Add(breakpoint);
+        }
+    }
+
+    public void Remove(Breakpoint breakpoint)
+    {
+        _breakpoints.Remove(breakpoint);
+
+        SynchronizeLists();
+    }
+
+    public void Replace(Breakpoint original, Breakpoint replacement)
+    {
+        var existingIndex = _breakpoints.IndexOf(original);
+
+        if (existingIndex < 0)
+        {
+            return;
+        }
+
+        _breakpoints[existingIndex] = replacement;
+
+        SynchronizeLists();
+    }
+
+    private void SynchronizeLists()
+    {
+        Register = _breakpoints.Where(x => x is RegisterBreakpoint).Cast<RegisterBreakpoint>().ToList();
+        Memory = _breakpoints.Where(x => x is MemoryBreakpoint).Cast<MemoryBreakpoint>().ToList();
+    }
+}