Add support for sub-M-cycle accuracy. Not sure how useful this is!

Author: MoleskiCoder

Z80/Z80.cs

@@ -479,9 +479,16 @@ public void LowerWR()
 
         private void MemoryUpdate(int ticks)
         {
+            Debug.Assert(ticks > 0, "Ticks must be greater than zero");
             this.OnWritingMemory();
+#if CYCLE_ACCURATE
+            this.Tick(ticks - 1);
+            this.LowerMREQ();
+            this.Tick();
+#else
             this.Tick(ticks);
             this.LowerMREQ();
+#endif
             this.LowerWR();
             this.Tick();
             base.MemoryWrite();
@@ -498,30 +505,71 @@ protected override void MemoryWrite()
 
         private void RefreshMemory()
         {
+            Debug.Assert(this.M1.Lowered(), "M1 must be lowered to refresh memory");
             this.Bus.Address.Assign(this.REFRESH, this.IV);
             this.LowerRFSH();
+#if CYCLE_ACCURATE
+            this.LowerMREQ();
+            this.Tick();
+#else
             this.Tick();
             this.LowerMREQ();
+#endif
             this.RaiseMREQ();
             this.RaiseRFSH();
         }
 
-        protected override byte MemoryRead()
+        private void SetMemoryRead()
         {
-            this.OnReadingMemory();
-            this.Tick();
             this.LowerMREQ();
             this.LowerRD();
-            this.Tick();
-            _ = base.MemoryRead();
+        }
+
+        private void ResetMemoryRead()
+        {
             this.RaiseRD();
             this.RaiseMREQ();
+        }
+        private void MemoryReadWithM1()
+        {
+            Debug.Assert(this.M1.Lowered());
+            this.Tick();
+            this.SetMemoryRead();
+            this.Tick();
+            _ = base.MemoryRead();
+            this.ResetMemoryRead();
+            this.RefreshMemory();
+        }
+
+        private void MemoryReadWithoutM1()
+        {
+            Debug.Assert(this.M1.Raised());
+#if CYCLE_ACCURATE
+            this.SetMemoryRead();
+            _ = base.MemoryRead();
+            this.Tick(2);
+#else
+            this.Tick();
+            this.SetMemoryRead();
+            this.Tick();
+            _ = base.MemoryRead();
+#endif
+            this.ResetMemoryRead();
+        }
+
+        protected override byte MemoryRead()
+        {
+            this.OnReadingMemory();
             if (this.M1.Lowered())
             {
-                this.RefreshMemory();
+                this.MemoryReadWithM1();
+            }
+            else
+            {
+                this.MemoryReadWithoutM1();
             }
-            this.Tick();
             this.OnReadMemory();
+            this.Tick();
             return this.Bus.Data;
         }
 
@@ -1472,7 +1520,22 @@ private void ExecuteOther(int x, int y, int z, int p, int q)
                                     if (this._displaced)
                                     {
                                         this.FetchDisplacement();
-                                        this.Execute(this.FetchByte());
+                                        {
+                                            this.ImmediateAddress();
+#if CYCLE_ACCURATE
+                                            this.OnReadingMemory();
+                                            this.Tick();
+                                            this.SetMemoryRead();
+                                            var instruction = base.MemoryRead();
+                                            this.Tick();
+                                            this.ResetMemoryRead();
+                                            this.Tick();
+                                            this.OnReadMemory();
+#else
+                                            var instruction = this.MemoryRead();
+#endif
+                                            this.Execute(instruction);
+                                        }
                                     }
                                     else
                                     {
@@ -1604,7 +1667,11 @@ private void HandleNMI()
             this.Restart(0x66);
         }
 
-        private void FetchDisplacement() => this._displacement = (sbyte)this.FetchByte();
+        private void FetchDisplacement()
+        {
+            Debug.Assert(this.M1.Raised(), "Displacement cannot be fetched during an M1 cycle");
+            this._displacement = (sbyte)this.FetchByte();
+        }
 
         // ** From the Z80 CPU User Manual
         // Figure 5 depicts the timing during an M1 (op code fetch) cycle. The Program Counter is
@@ -2341,16 +2408,32 @@ private void WritePort(Register16 port)
             this.WritePort();
         }
 
-        private void WritePort()
+        private void SetIOWrite()
         {
-            this.MEMPTR.Assign(this.Bus.Address);
-            this.Tick(2);
             this.LowerIORQ();
             this.LowerWR();
-            this.Tick();
-            this.Ports.Write(this.Bus.Address, this.Bus.Data);
+        }
+
+        private void ResetIOWrite()
+        {
             this.RaiseWR();
             this.RaiseIORQ();
+        }
+
+        private void WritePort()
+        {
+            this.MEMPTR.Assign(this.Bus.Address);
+            this.Tick();
+#if CYCLE_ACCURATE
+            this.SetIOWrite();
+            this.Tick();
+#else
+            this.Tick();
+            this.SetIOWrite();
+#endif
+            this.Tick();
+            this.Ports.Write(this.Bus.Address, this.Bus.Data);
+            this.ResetIOWrite();
             this.Tick();
         }
 
@@ -2367,19 +2450,37 @@ private void ReadPort(Register16 port)
             this.ReadPort();
         }
 
-        private void ReadPort()
+        private void SetIORead()
         {
-            this.MEMPTR.Assign(this.Bus.Address);
-            this.Tick(2);
             this.LowerIORQ();
             this.LowerRD();
-            this.Bus.Data = this.Ports.Read(this.Bus.Address);
-            this.Tick();
+        }
+
+        private void ResetIORead()
+        {
             this.RaiseRD();
             this.RaiseIORQ();
+
+        }
+
+        private void ReadPort()
+        {
+            this.MEMPTR.Assign(this.Bus.Address);
+            this.Tick();
+#if CYCLE_ACCURATE
+            this.SetIORead();
+            this.Bus.Data = this.Ports.Read(this.Bus.Address);
+            this.Tick();
+#else
+            this.Tick();
+            this.SetIORead();
+            this.Bus.Data = this.Ports.Read(this.Bus.Address);
+#endif
+            this.Tick();
+            this.ResetIORead();
             this.Tick();
         }
 
-        #endregion
+#endregion
     }
 }