CSPspEmu.CWCheatEntry._Patch C# (CSharp) Method

_Patch() private method

private _Patch ( PspMemory PspMemory ) : void
PspMemory PspMemory
return void
        private void _Patch(PspMemory PspMemory)
        {
            uint Info = this.Code & 0x0FFFFFFF;
            //uint Address = 0x08804000 + Info;
            uint Address = 0x08800000 + Info;
            try
            {
                switch (OpCode)
                {
                    // [t]8-bit Constant Write 0x0aaaaaaa 0x000000dd
                    case 0x0:
                        PspMemory.WriteSafe(Address, (byte)BitUtils.Extract(Values[0], 0, 8));
                        break;
                    // [t]16-bit Constant write 0x1aaaaaaa 0x0000dddd
                    case 0x1:
                        PspMemory.WriteSafe(Address, (ushort)BitUtils.Extract(Values[0], 0, 16));
                        break;
                    // [t]32-bit Constant write 0x2aaaaaaa 0xdddddddd
                    case 0x2:
                        PspMemory.WriteSafe(Address, (uint)BitUtils.Extract(Values[0], 0, 32));
                        break;
                    // 32-bit Multi-Address Write/Value increase	0x4aaaaaaa 0xxxxxyyyy 0xdddddddd 0xIIIIIIII
                    case 0x4:
                        {
                            var Count = BitUtils.Extract(Values[0], 16, 16);
                            var Increment = BitUtils.Extract(Values[0], 0, 16);
                            var Value = BitUtils.Extract(Values[1], 0, 32);
                            var IncrementValue = BitUtils.Extract(Values[2], 0, 32);
                            for (int n = 0; n < Count; n++)
                            {
                                PspMemory.WriteSafe((uint)(Address + n * Increment), (uint)(Value + IncrementValue * n));
                            }
                        }
                        break;
                    case 0x8:
                        // 16-bit Multi-Address Write/Value increas	0x8aaaaaaa 0xxxxxyyyy 0x1000dddd 0xIIIIIIII
                        if (BitUtils.Extract(Values[1], 28, 4) == 1)
                        {
                            var Count = BitUtils.Extract(Values[0], 16, 16);
                            var Increment = BitUtils.Extract(Values[0], 0, 16);
                            var Value = BitUtils.Extract(Values[1], 0, 16);
                            var IncrementValue = BitUtils.Extract(Values[2], 0, 32);
                            for (int n = 0; n < Count; n++)
                            {
                                PspMemory.WriteSafe((uint)(Address + n * Increment), (ushort)(Value + IncrementValue * n));
                            }
                        }
                        // 8-bit Multi-Address Write/Value increase	0x8aaaaaaa 0xxxxxyyyy 0x000000dd 0xIIIIIIII
                        else
                        {
                            var Count = BitUtils.Extract(Values[0], 16, 16);
                            var Increment = BitUtils.Extract(Values[0], 0, 16);
                            var Value = BitUtils.Extract(Values[1], 0, 8);
                            var IncrementValue = BitUtils.Extract(Values[2], 0, 32);
                            for (int n = 0; n < Count; n++)
                            {
                                PspMemory.WriteSafe((uint)(Address + n * Increment), (byte)(Value + IncrementValue * n));
                            }
                        }
                        break;
                    // 16-bit XOR - 0x7aaaaaaa 0x0005vvvv
                    // 8-bit  XOR - 0x7aaaaaaa 0x000400vv
                    // 16-bit AND - 0x7aaaaaaa 0x0003vvvv
                    // 8-bit  AND - 0x7aaaaaaa 0x000200vv
                    // 16-bit OR  - 0x7aaaaaaa 0x0001vvvv
                    // 8-bit  OR  - 0x7aaaaaaa 0x000000vv
                    case 0x7:
                        {
                            uint SubOpCode = (Values[0] >> 16) & 0xFFFF;
                            uint SubValue = (Values[0] >> 0) & 0xFFFF;
                            switch (SubOpCode)
                            {
                                // 8-bit  OR  - 0x7aaaaaaa 0x000000vv
                                case 0:
                                    PspMemory.WriteSafe(Address, (byte)(PspMemory.ReadSafe<byte>(Address) | (SubValue & 0xFF)));
                                    break;
                                default:
                                    Console.Error.WriteLine("Invalid CWCheatOpCode: 0x{0:X} : 0x{1:X}", OpCode, SubOpCode);
                                    break;
                            }
                        }
                        break;
                    default:
                        Console.Error.WriteLine("Invalid CWCheatOpCode: 0x{0:X}", OpCode);
                        break;
                }
            }
            catch (Exception Exception)
            {
                throw (new Exception(String.Format("At Address: 0x{0:X}", Address), Exception));
            }
        }