Lynx Code Manager


Finally, Code-Types and a cheat code manager for PC!




Description

This tool allows you to execute Cheat Codes similar to the Action Replay or GameShark ones. You can create, edit and save cheat lists for each game. This tool comes with a Memory viewer which can be opened multiple times to watch more than one memory area. Last but not least it can be used to create memory dumps.




Features




Usage




Lynx Code Types

General information:
P: Pointer State - 0 = no pointer, 1 = uses pointer
S: Value Size - 0 = 8 Bits, 1 = 16 Bits, 2 = 32 Bits, 3 = 64 Bits
L: Address in BE (right-justified), if P = 1 then L can be used to determine an unsigned offset
Q: If p = 1, then L is replaced by Q
V: Value (right-justified). Length depends on S



00 - RAM Write

FormattingExample
00PSLLLL LLLLLLLL
VVVVVVVV VVVVVVVV
*This writes the value VVVVVVVV VVVVVVVV of size S to LLLL LLLLLLLL.
00001122 33445566
00000000 000000FF
*This writes the 8-bit value of 0xFF to 0x112233445566


01 - String Write

FormattingExample
01P0YYYY 00000000
0000LLLL LLLLLLLL
VVVVVVVV VVVVVVVV
VVVVV....

Y = How many bytes to write
V = Array of bytes starting at the top left. Fill unused bytes of a line with 0
0100000A 00000000
00000000 0ED1454C
53617565 726b7261
7574
0000 00000000
*This writes the 0x0A (10) bytes to 0x0ED1454C.


02 - Skip Write

FormattingExample
02PSLLLL LLLLLLLL
VVVVVVVV VVVVVVVV
IIIIIIII MYYYYYYY
*I: Address increment (unsigned) M: Mode. 0 = add increment, 1 = subtract increment Y: Count, how many skip writes to perform
02001122 33445566
00000000 000000FF
IIIIIIII MYYYYYYY
*This writes the 8-bit value of 0xFF to 0x112233445566


08 - Conditional: If key is pressed (Experimental)

FormattingExample
080000XX 000000VV
*XX: interleave level. Determines to which end-if to jump if the condition is false
VV: Key Value (ASCII hex)
 *Note, as of now only one of these codes can be used at a time
080000XX 000000VV
D00000XX BADF000D


09 - Conditional: If (unsigned)

FormattingExample
09PS00XX 00000000
0000LLLL LLLLLLLL
VVVVVVVV VVVVVVVV
D00000XX BADF000D
*T: Type 0 = if equal to 1 = if not equal to 2 = if greater than 3 = if greater than or equal 4 = if less than 5 = if less than or equal 6 = AND (if at least VV bits are present) 7 = OR (if at least one of VV bits is present) XX: interleave level. Determine to which end if to jump if the condition is false
090000XX 00000000
00001122 33445566
00000000 000000FF
D00000XX BADF000D
*This writes the 8-bit value of 0xFF to 0x112233445566


0A - Conditional: If value between (unsigned)

FormattingExample
0APS00XX 00000000
0000LLLL LLLLLLLL
VVVVVVVV VVVVVVVV
WWWWWWWW WWWWWWWW
D00000XX BADF000D
*T: Type. 0 = value between V and W 1 = value not between V and W XX: interleave level. Determine to which end if to jump if the condition is false
0A0000XX 00000000
00001122 33445566
00000000 000000FF
00000000 000000FF
D00000XX BADF000D
*This writes the 8-bit value of 0xFF to 0x112233445566


20 - Load Integer

FormattingExample
20PSRRMM 00000000
0000LLLL LLLLLLLL
*RR = Register in which the value should be stored
MM = Mode
  00 and 01 = Scalar. Loads single int of size S into RR
  02 - FF = Packed. Number of consecutive values of size S to store into registers starting at RR
20020400 00000000
00007FFE 15ED5418
*This loads one 32-bit integer from 0x7FFE15ED5418 into register 4.


21 - Store Integer

FormattingExample
21PSRRMM 00000000
0000LLLL LLLLLLLL
*RR = Register from where the value should be loaded
MM = Mode
  00 and 01 = Scalar. Loads single int of size S from RR
  02 - FF = Packed. Number of values of size S to store from registers starting at RR and to be stored at LLLL LLLLLLLL consecutively.
21020400 00000000
00007FFE 15ED5418
*This loads one 32-bit integer from register 4 and stores it at 0x7FFE15ED5418.


22 - Integer Operation

FormattingExample
220SMMTT RRЯЯ0000
VVVVVVVV VVVVVVVV
RR = First register of which to operate with. This one will hold the result of the operation. ЯЯ = Second Register of which value to operate with. Usage depents on type. MM = Mode:
00 and 01 = Scalar. Reads single int of size S from RR/ЯЯ. 02 - FF = Packed. Number of consecutive values of size S to read from registers starting at RR/ЯЯ.
    TT = Operation Type
  • 00: add RR # ЯЯ
  • 01: subtract RR # ЯЯ
  • 02: multiply RR # ЯЯ
  • 03: divide RR # ЯЯ
  • 04: modulu RR # ЯЯ
  • 05: square root of RR
  • 06: RR to the power of ЯЯ
  • 07: negate RR
  • 08: NOT RR
  • 09: AND RR # ЯЯ
  • 0A: OR RR # ЯЯ
  • 0B: NAND RR # ЯЯ
  • 0C: NOR RR # ЯЯ
  • 0D: XOR RR # ЯЯ
  • 0E: XNOR RR # ЯЯ
  • 0F: Int to Float float-RR # ЯЯ
  • 10: Int to Double double-RR # ЯЯ
  • 11: add RR # static-ЯЯ
  • 12: subtract RR # static-ЯЯ
  • 13: multiply RR # static-ЯЯ
  • 14: divide RR # static-ЯЯ
  • 15: modulu RR # static-ЯЯ
  • 16: AND RR # static-ЯЯ
  • 17: OR RR # static-ЯЯ
  • 18: NAND RR # static-ЯЯ
  • 19: NOR RR # static-ЯЯ
  • 1A: XOR RR # static-ЯЯ
  • 1B: XNOR RR # static-ЯЯ
  • 1C: add RR # V
  • 1D: subtract RR # V
  • 1E: multiply RR # V
  • 1F: divide RR # V
  • 20: modulu RR # V
  • 21: RR to the power of V
  • 22: AND RR # V
  • 23: OR RR # V
  • 24: NAND RR # V
  • 25: NOR RR # V
  • 26: XOR RR # V
  • 27: XNOR RR # V
  • 28: shift left RR by V
  • 29: shift right RR by V
22030326 12000000
CDCDCDCD CDCDCDCD
*This operates a 64-bit XOR-Operation with 0xCDCDCDCDCDCDCDCD on each of the 3 registers starting at register 18 (0x12).


23 - Load Float Single

FormattingExample
23P0RRMM 00000000
0000LLLL LLLLLLLL
*RR = Register in which the value should be stored
MM = Mode
  00 and 01 = Scalar. Loads float of single precision into RR
  02 - FF = Packed. Number of consecutive floats of single precision to store into registers starting at RR
23000003 00000000
00000220 12D854E0
*This loads 3 floats of single precision starting at 0x022012D854E0 into registers 0, 1 and 2.


24 - Store Float Single

FormattingExample
24P0RRMM 00000000
0000LLLL LLLLLLLL
*RR = Register where the float should be read from
MM = Mode
  00 and 01 = Scalar. Writes float of single precision from RR to LLLLLLLLLLLL
  02 - FF = Packed. Number of consecutive floats of single precision to write from registers starting at RR to LLLL LLLLLLLL.
24000003 00000000
00000220 12D854E0
*This writes 3 3 floats of single precision of inside registers 0, 1 and 2 to 0x022012D854E0.


25 - Float Single Operation

FormattingExample
2500MMTT RRЯЯ0000
00000000 VVVVVVVV
RR = First register of which to operate with. This one will hold the result of the operation. ЯЯ = Second Register of which value to operate with. Usage depents on type. MM = Mode:
00 and 01 = Scalar. Reads single Float Single from RR/ЯЯ. 02 - FF = Packed. Number of consecutive Float Single to read from registers starting at RR/ЯЯ.
    TT = Operation Type
  • 00: add RR # ЯЯ
  • 01: subtract RR # ЯЯ
  • 02: multiply RR # ЯЯ
  • 03: divide RR # ЯЯ
  • 04: square root of RR
  • 05: RR to the power of ЯЯ
  • 06: float to int int-RR # RR
  • 07: float to double double-RR # RR
  • 08: add RR # static-ЯЯ
  • 09: subtract RR # static-ЯЯ
  • 0A: multiply RR # static-ЯЯ
  • 0B: divide RR # static-ЯЯ
  • 0C: RR to the power of static-ЯЯ
  • 0D: add RR # VV
  • 0E: subtract RR # VV
  • 0F: multiply RR # VV
  • 10: divide RR # VV
  • 11: RR to the power of VV
2500030D 00000000
00000000 3E800000
*This operates an Addition with 0x3E800000 on each of the 3 registers starting at register 00.


26 - Load Float Double

FormattingExample
26P0RRMM 00000000
0000LLLL LLLLLLLL
*RR = Register in which the value should be stored
MM = Mode
  00 and 01 = Scalar. Loads float of Double precision into RR
  02 - FF = Packed. Number of consecutive floats of Double precision to store into registers starting at RR
26000003 00000000
00000220 12D854E0
*This loads 3 floats of double precision starting at 0x022012D854E0 into registers 0, 1 and 2.


27 - Store Float Double

FormattingExample
27P0RRMM 00000000
0000LLLL LLLLLLLL
*RR = Register where the float should be read from
MM = Mode
  00 and 01 = Scalar. Writes float of double precision from RR to LLLLLLLLLLLL
  02 - FF = Packed. Number of consecutive floats of double precision to write from registers starting at RR to LLLL LLLLLLLL.
27000003 00000000
00000220 12D854E0
*This writes 3 3 floats of double precision of inside registers 0, 1 and 2 to 0x022012D854E0.


28 - Float Double Operation

FormattingExample
2800MMTT RRЯЯ0000
VVVVVVVV VVVVVVVV
RR = First register of which to operate with. This one will hold the result of the operation. ЯЯ = Second Register of which value to operate with. Usage depents on type. MM = Mode:
00 and 01 = Scalar. Reads single Float Double from RR/ЯЯ. 02 - FF = Packed. Number of consecutive Float Double to read from registers starting at RR/ЯЯ.
    TT = Operation Type
  • 00: add RR # ЯЯ
  • 01: subtract RR # ЯЯ
  • 02: multiply RR # ЯЯ
  • 03: divide RR # ЯЯ
  • 04: square root of RR
  • 05: RR to the power of ЯЯ
  • 06: float to int int-RR # RR
  • 07: float to double double-RR # RR
  • 08: add RR # static-ЯЯ
  • 09: subtract RR # static-ЯЯ
  • 0A: multiply RR # static-ЯЯ
  • 0B: divide RR # static-ЯЯ
  • 0C: RR to the power of static-ЯЯ
  • 0D: add RR # VV
  • 0E: subtract RR # VV
  • 0F: multiply RR # VV
  • 10: divide RR # VV
  • 11: RR to the power of VV
2800030D 00000000
3FF00000 00000000
*This operates an Addition with 0x3FF0000000000000 on each of the 3 registers starting at register 00.


30 - Load Pointer

FormattingExample
30PSLLLL LLLLLLLL
XX00STRT OF-RANGE
0000END- OF-RANGE
S = size. 0 = 32-bits, 1 = 64-bits
XX = to which branch label to jump if pointer is out of range/invalid
STRT OF-RANGE: Smallest pointer to be accepted
END- OF-RANGE: Biggest pointer to be accepted
30001122 33445566
XX00STRT OF-RANGE
0000END- OF-RANGE


31 - Add/Sub offset to/from pointer

FormattingExample
3100000M QQQQQQQQ
*M = Mode. 0 = add, 1 = subtract
Q = Unsigned offset
31000000 0080C048
*This permanently adds the unsigned offset of 0x0080C048 to the previosly loaded pointer.


D0 - End if

FormattingExample
D00000XX BADF000D
*XX = Endif level
D0000000 BADF000D
*If the IF condition of XX = 00 is false, the execution will skip all lines of codes until here.


D1 - Jump to here if pointer is invalid

FormattingExample
D10000XX ABAD1DEA
*XX = Pointer level
D1000001 ABAD1DEA
*If the pointer of level XX = 01 is invalid, the execution will skip all lines of codes until here.


D2 - No Operation

Formatting
D1000000 DEADCODE
*Does effectively nothing. Used as placeholder sometimes.





Change log

  1. r1
    • initial release



ToDo