• Before registering an account on PlayerSquared you must first agree that you are at least 13 years of age & have read & agree to our Terms & rules & our Privacy policy.
  • To hide your download link, use the following BBCodes:
    You can set specific reactions (like "Thanks," "Love," etc.) that must be selected to unlock the download link. List the reaction numbers like this: 1, 2, 3, etc. 1 = Thanks 2 = Love 3 = Haha 4 = Wow 6 = Canada Thanks

    or you can use:
    Which allows you to charge a certain credit amount in order for someone to get access to the download link.

    The button to unlock the link will appear in the bottom right corner of the post.

Save Wizard Custom Quick Code Formats

Dynamite

Dynamite

Interesting
VIP MEMBER
January 12, 2019
38
154
0
#1
Please read:
> The majority of PS4 saves use Little Endian but Save Wizard uses Big Endian. Save Wizard will automatically swap the Endian for those specific games. Therefore, "000F423F" in a code will write as "3F420F00" in the save. This is true for all standard write codes. If either the code does not write or writes in a unique way, it does not swap the Endian. Such as the Search Value for the Pointer Codes (Types 8/B/C) and Bytes Written in unique ways (Type A).

> If you use a Pointer Offset Code (Types 8/9/B/C) followed by a code that uses the Pointer Offset Type; the Address written in that code will then offset forwards from the Pointer Offset Address instead of it being the Address itself.

> These are not all of the code Types nor are they complete translations for each code. Save Wizard / Game Genie has never really publicly posted anything about the code formats so the majority have been discovered over the course of the past decade. Shout out to every single code hunter and the community as a whole!
Code Type 0: Standard 1 Byte Write:
Writes 1 Byte (8 Bits) to a specific Address

0BYYYYYY 000000XX

B = Offset Type
​0 = Default
8 = Offset from Pointer​
Y = Address
X = Bytes to Write

Example:

00000456 00000063

00000456 00000063 - Normal Offset
00000456 00000063 - Writes to this Address
00000456 00000063 - Writes these Bytes

vI8Ctaw.png
Code Type 1: Standard 2 Byte Write:
Writes 2 Bytes (16 Bits) to a specific Address

1BYYYYYY 0000XXXX

B = Offset Type
0 = Default
8 = Offset from Pointer​
Y = Address
X = Bytes to Write

Example:

10001E24 000003E7

10001E24 000003E7 - Normal Offset
10001E24 000003E7 - Writes to this Address
10001E24 000003E7- Writes these Bytes

w91oSgv.png
Code Type 2: Standard 4 Byte Write:
Writes 4 Bytes (32 Bits) to a specific Address

2BYYYYYY XXXXXXXX

B = Offset Type
0 = Default
8 = Offset from Pointer​
Y = Address
X = Bytes to Write

Example:

20000250 3B9AC9FF

20000250 3B9AC9FF - Normal Offset
20000250 3B9AC9FF - Writes to this Address
20000250 3B9AC9FF - Writes these Bytes

HOAcn3Q.png
Code Type 3: Increase / Decrease Write:
Increases or Decreases a specified amount of data from a specific Address
This does not add/remove Bytes into the save, it just adjusts the value of the Bytes already in it

3BYYYYYY XXXXXXXX

B = Byte Value & Offset Type
0 = Add 1 Byte (000000XX)
1 = Add 2 Bytes (0000XXXX)
2 = Add 4 Bytes
3 = Add 8 Bytes
4 = Sub 1 Byte (000000XX)
5 = Sub 2 Bytes (0000XXXX)
6 = Sub 4 Bytes
7 = Sub 8 Bytes
8 = Offset from Pointer; Add 1 Byte (000000XX)
9 = Offset from Pointer; Add 2 Bytes (0000XXXX)
A = Offset from Pointer; Add 4 Bytes
B = Offset from Pointer; Add 8 Bytes
C = Offset from Pointer; Sub 1 Byte (000000XX)
D = Offset from Pointer; Sub 2 Bytes (0000XXXX)
E = Offset from Pointer; Sub 4 Bytes
F = Offset from Pointer; Sub 8 Bytes​
Y = Address
X = Bytes to Add/Sub

Example:

31003E3D 0000112A

31003E3D 0000112A - Add 2 Bytes Worth
31003E3D 0000112A - Add to this Address
31003E3D 0000112A - Add These Bytes

Before:
xhvXnnu.png

After:
Ai70z3i.png


For the 8 Byte Value Type, it will write 4 Bytes of data but will continue to write the bytes afterwards if it cannot write any more.
Code Type 4: Multi-Write (Repeater):
Writes Bytes numerous times to an increasing Address

4BYYYYYY XXXXXXXX
4CCCDDDD ZZZZZZZZ

B = Byte Value & Offset Type
0 = 1 Byte (Only Writes 000000XX)
1 = 2 Bytes (Only Writes 0000XXXX)
2 = 4 Bytes
8 = Offset from Pointer; 1 Byte (Only Writes 000000XX)
9 = Offset from Pointer; 2 Bytes (Only Writes 0000XXXX)
A = Offset from Pointer; 4 Bytes​
Y = Address
X = Bytes to Write
C = Amount of times to repeat Write
D = Increases Address by per Write
Z = Increases Value by per Write

Example:

41004500 00000100
4004000C 00000002
​
41004500 00000100 - Writes 2 Bytes Worth
4004000C 00000002 - Writes Four Times

41004500 00000100 - Writes to this Address
4004000C 00000002 - Distance Between Writes

41004500 00000100 - Writes these Bytes
4004000C 00000002 - Increases By 2 Per Write

aGDrm3W.png
Code Type 5: Copy and Paste:
Copies Bytes from a specific Address and Writes it to another

5BYYYYYY XXXXXXXX
5BZZZZZZ 00000000

B = Offset Type
0 = Default
8 = Offset from Pointer​
Y = Address to Copy Bytes
X = Amount of Bytes to Copy
1 = 1 Bytes
2 = 2 Bytes
So on...​
Z = Address to Paste Bytes

Example:

500000A2 00000004
500000B4 00000000

500000A2 00000004 - Normal Offset
500000B4 00000000 - Normal Offset

500000A2 00000004 - Copies the Bytes from this Address
500000B4 00000000 - Pastes Bytes to this Address

500000A2 00000004 - Copies Four Bytes Worth
500000B4 00000000

gY1vNo8.png
Code Type 7: No More / No Less than Write:
Writes Bytes up to a specified Maximum/Minimum to a specific Address

7BYYYYYY XXXXXXXX

B = Byte Value & Offset Type
0 = No Less Than: 1 Byte (000000XX)
1 = No Less Than: 2 Bytes (0000XXXX)
2 = No Less Than: 4 Bytes
4 = No More Than: 1 Byte (000000XX)
5 = No More Than: 2 Bytes (0000XXXX)
6 = No More Than: 4 Bytes
8 = Offset from Pointer; No Less Than: 1 Byte (000000XX)
9 = Offset from Pointer; No Less Than: 2 Bytes (0000XXXX)
A = Offset from Pointer; No Less Than: 4 Bytes
C = Offset from Pointer; No More Than: 1 Byte (000000XX)
D = Offset from Pointer; No More Than: 2 Bytes (0000XXXX)
E = Offset from Pointer; No More Than: 4 Bytes​
Y = Address
X = Bytes to Write

This code is the same as a standard write code however it will only write the bytes if the current value at the address is no more or no less than X.
For example, you can use a no less than value to make sure the address has more than X but will take no effect if it already has more than the value on the save.
Code Type 8: Forward Byte Search (Set Pointer):
Searches Forwards for a specified Value and saves the Value's Address as the Pointer Offset
Will start from the beginning of the save file, but can be changed using a previous Pointer Offset

8BCCYYYY XXXXXXXX
*Other Code Here, Use Specific Offset Type*

B = Offset Type
0 = Default
8 = Offset from Pointer​
C = Amount of Times to Find until Pointer Set
Y = Amount of Bytes to Search
1 = 1 Byte
2 = 2 Bytes
and so on...​
X = Bytes to Search, use Multiple Lines if Needed

Example:

80010004 01B00117 - Searches for four bytes of "01B00117" Once using Default Offset
28000010 7FFFFFFF - Standard Write code using the "8" Offset Type (Refer to Code Type 2) and offsets by 0x10

ErrPlgp.png
Code Type 9: Pointer Manipulator: (Set/Move Pointer)
Adjusts the Pointer Offset using numerous Operators

9Y000000 XXXXXXXX

Y = Operator
0 = Set Pointer to Big Endian value at XXXXXXXX
1 = Set Pointer to Little Endian value at XXXXXXXX
2 = Add X to Pointer
3 = Sub X to Pointer
4 = Set Pointer to the end of file and subtract X
5 = Set Pointer to X​
X = Value to set / change
Code Type A: Mass Write:
Writes a specified amount of Bytes to a specific Address

ABYYYYYY XXXXXXXX
ZZZZZZZZ ZZZZZZZZ

B = Offset Type
0 = Normal
8 = Offset from Pointer​
Y = Writes to this Address
X = Amount of Bytes to Write
Z = Bytes to Write, use Multiple Lines if Needed

Example:

A0004510 00000010
11223344 55667788
99AABBCC DDEEFF00

A0004510 0000000F - Writes to this Address
11223344 55667788
99AABBCC DDEEFF00

A0004510 0000000F - Writes this many Bytes
11223344 55667788 - Bytes to Write (1)
99AABBCC DDEEFF00 - Bytes to Write (2)

o3zOY1n.png
Code Type B: Backward Byte Search (Set Pointer):
Searches Backwards for a specified Value and saves the Value's Address as the Pointer Offset
Will start from the end of the save file, but can be changed using a previous Pointer Offset

BBCCYYYY XXXXXXXX
*Other Code Here, Use Specific Offset Type*

B = Offset Type
0 = Default
8 = Offset from Pointer​
C = Amount of Times to Find until Pointer Set
Y = Amount of Bytes to Search
1 = 1 Byte
2 = 2 Bytes
and so on...​
X = Bytes to Search, use Multiple Lines if Needed
Code Type C: Address Byte Search (Set Pointer):
Searches for a Value from a specified Address and saves the new Value's Address as the Pointer Offset
Rather than searching for Bytes already given such as code types 8 and B, this code will instead search using the bytes at a specific Address

CBFFYYYY XXXXXXXX
*Other Code Here, Use Specific Offset Type*

B = Offset Type
0 = Search Forwards from Address Given
4 = Search from 0x0 to Address Given
8 = Offset from Pointer; Search Forwards from Address Given
C = Offset from Pointer; Search from 0x0 to Address Given​
F = Amount of Times to Find until Pointer Set
Y = Amount of Bytes to Search from Address
1 = 1 Byte
2 = 2 Bytes
and so on...​
X = Address of Bytes to Search with
Code Type D: 2 Byte Test Commands (Code Skipper):
Test a specific Address using an Operation; skips the following code lines if Operation fails

DBYYYYYY CCDDXXXX

B = Offset Type
0 = Normal
8 = Offset from Pointer​
Y = Address to test
C = Lines of code to skip if test fails
D = Test Operation
0 = Equal
1 = Not Equal
2 = Greater Than (Value at the Address is greater than the tested value)
3 = Less Than (Value at the Address is less than the tested value)​
X = Value to test
 
Last edited:
  • Like
  • Love
Reactions: gagliardi, polbaas, TheJuicyMoose and 54 others
#3
Seeing how much work you gotta do just to make a quick code is crazy, and I appreciate everybody that does it. I'll love to do this myself, but I don't have the skills or the patience to do it.
 
#7
Devaraja said:
I see thank you. Do you know how would I input longer address? for example I want to write 1 byte to this address 10ACDBB
Click to expand...

Code type 9 should do the trick.
I.E. "95000000 010ACDBB"
And then just make sure you use the pointer offset for the write codes.

Example:
95000000 010ACDBB
08000010 000000FF
Will write "FF" at 0x10ACDCB
 
#8
010ACDBB 000000FF


and and all (Counts or Pointer types )still allow you to use anything under and above it so example

Max address you can use is

07FFFFFF

Since this would be
07 if not a pointer
and 07FFFFFF+08 if a pointer = 0FFFFFFF

This is the same for 4 type .. and many of the other types .. u get full control of an address up to 0x07FFFFFF
 
Last edited:
#12
AxUU said:
Example 1: All Skills Level 100
8001000C 05000000
00000000 06000000
4A00000C 42C80000
40120008 00000000

Example 2: + 100.000 EXP
8001000A 80BF0000
00000000 80BF0000
28000034 47C35000
28000038 00000000
Click to expand...

"8001000C 05000000
00000000 06000000"
is all one code. It's a search code and searches for 12 bytes (0C) "05000000 00000000 06000000" *Refer to Code Type 8
Same with the 2nd part that starts with an 8 (Except only searches for 10 bytes (0A).

"4A00000C 42C80000
40120008 00000000"
is also one code, however that last group of bytes just decides if it increases per write *Refer to Code Type 4

"28000038 00000000" Is just a standard 4 Byte Write Code and just writes 00000000 at the given offset.

*Sorry if this is still confusing, I wrote this right before going to bed and I'm tired :peasant:
 
#13
Dynamite said:
"8001000C 05000000
00000000 06000000"
is all one code. It's a search code and searches for 12 bytes (0C) "05000000 00000000 06000000" *Refer to Code Type 8
Same with the 2nd part that starts with an 8 (Except only searches for 10 bytes (0A).

"4A00000C 42C80000
40120008 00000000"
is also one code, however that last group of bytes just decides if it increases per write *Refer to Code Type 4

"28000038 00000000" Is just a standard 4 Byte Write Code and just writes 00000000 at the given offset.

*Sorry if this is still confusing, I wrote this right before going to bed and I'm tired :peasant:
Click to expand...

Thanks Dynamite! Your explanation was good. Thank you for responding so quickly.
 
#14
Maybe someone can help me how to edit in advanced mode this quick codes:

Activator(Must Be On) V1.12

80010006 5F502EE2
03010000 00000000
93000000 0000000B

All Fast Travel
4A00707B 00000002
40880009 00000000

Thanks!
 
#18
Dynamite said:
Well then, I never even noticed that mistake when I made this lmao. Yeah it should be "80010004 01B00117" instead of "80010002"
The original example I had was only searching for 0117. Good catch :pepedetective:
Click to expand...

Well it searched for 01B0 .. since search reads from left to right . ;)
just to clear that up a little more ..

Just posting to say, with this information in this topic .. Many Can take the time and look and figure out codes .. Just wish it was a bit more active in the Code finding scene :P
 
#19
Dear Dynamite
I tried to create a code
Currently got problems, if you have time hope you can help me

80020006 C85000B0
E7030000 00000000
A800000C 00000006
6E1900B0 01000000 （）
The quick code is fine up to the current location

I want my code below to continue along the position of the pointer at the end of the previous code. And they all seem to run in a loop on the same line.
A8000006 00000006
BA1800B0 01000000
A8000006 00000006
A41A00B0 01000000
A8000006 00000006
C21A00B0 01000000
 
#20
wenaisheixin said:
Dear Dynamite
I tried to create a code
Currently got problems, if you have time hope you can help me

80020006 C85000B0
E7030000 00000000
A800000C 00000006
6E1900B0 01000000 （）
The quick code is fine up to the current location

I want my code below to continue along the position of the pointer at the end of the previous code. And they all seem to run in a loop on the same line.
A8000006 00000006
BA1800B0 01000000
A8000006 00000006
A41A00B0 01000000
A8000006 00000006
C21A00B0 01000000
Click to expand...

Where you have A8000006, the 000006 is where it offsets away from the pointer. You'd have to change this number to whatever address you'd like to write at. Currently it'll find the bytes you're searching for, then offset 0x6 forwards and write
 
You must log in or register to reply here.
Top Bottom
Back
Menu