kuntz
/
Gamehacking-Archive
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
Gamehacking-Archive/The Secrets of Professional...

12462 lines
539 KiB
HTML
Raw Permalink Blame History Escape

<!-- saved from url=(0048)https://macrox.gshi.org/The%20Hacking%20Text.htm -->
<html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8"><title>The Secrets of Professional GameShark(tm) Hacking</title>
<meta content="MSHTML 6.00.2800.1170" name="GENERATOR"><!-- base href="http://gshi.org/faqs/hackv500c.html" --></head><body font="COURIER NEW" alink="#ff0000" link="#0000ff" vlink="#880000">
<pre> ____ ______ ______ THE ______ ______ ____
/ \ | ___| | | _____ | ___| |_ _| / \
| |__| | |__ | |__| | \ | |__ | | | |__|
\ \ | __| | | | | | | __| | | \ \
_\ \ | | | |__ | / | | | | _\ \
| | | | |___ | | | | | \ | |___ | | | | |
\____/ |______| |______| |___|__\ |______| |__| \____/
Of Professional Gameshark(tm) Hacking
_____ 0001110101001110010110100011
..~` a`~~.. 110100000100001000100000101000001
..~` }100000111000110001110001100011111110
-----` /\/\/\/10100011100110000111001100001110011000
`. \\\ | 00010001001111110010011111100100111111100
; \/\/\100100111001100001110011000011101100010
.` ___/01000111000110001110001100011100110010
; ..~~~~```` 11011000100100100101010100100110101001
.` ..``
; ..``
; .`
.-` .`
.-` ,` "The most elaborate, in-depth hacking guide
/ .. . for Game Cheat Devices, ANYWHERE!"
|.-`` `. \
`.|
[Originally By: Kong K Rool* and Macrox]
with additions by [Tolos, DGenerateKane,
HyperHacker, Viper187, and Kenobi]
-----------------------------------------------
<b><i><font size="+1">Table Of Contents</font></i></b>
-----------------------------------------------
<b> Section 1 : <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#section_1">Foreword</a></b><p>
<b>I <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#this_version">This Version</a></b>
<b>II <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#whats_new">What's New</a></b>
<b>III <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#coming_soon">Coming Soon</a></b>
<b>IV <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#dedication">Dedication</a></b>
<b>V <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#preface">Preface</a></b>
<b>VI <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#Acknowledgments">Acknowledgments</a></b>
<b> Section 2 : <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#section_2">Hacking</a></b>
<b>VII <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#introduction">Introduction</a></b>
<b>VIII <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hacking_basics">Hacking Basics - Theory</a></b>
</p><ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#know_the_code">Know The Code</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#systems_of_counting">Systems Of Counting Or Number Base</a>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#offsets">Offsets</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#decimal">Decimal</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#binary">Binary</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#bitwisemath">Bitwise Operations</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hexadecimal">Hexadecimal</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#octal">Octal</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#ascii">ASCII</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#floatingpoints">Floating Points</a>
</li></ul></li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#about_most_gameshark_hackers">About Most GameShark Hackers</a></li>
</ul><b>IX. <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#how_to_guide">How-to Guide - Getting Started</a></b>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#what_do_i_need">What do I need?</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#what_do_i_need_to_know">What do I need to know?</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#learn_your_shark">Learn Your Shark - Code Types, Buttons and all. </a>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_code_types">Nintendo 64 Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#playstation_code_types">Playstation Gameshark Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#psx_xp_code_types">Playstation Xploder/Xplorer Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#ps2_code_types">Playstation 2 Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#dc_code_types">Sega Dreamcast Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#ssaturn_code_types">Sega Saturn Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gameboy_code_types">Gameboy/Gameboy Color Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gsa_code_types">Gameboy Advance Gameshark V1/V2 Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#cba_code_types">Gameboy Advance Codebreaker Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#AR_V3_Code_Types">Action Replay V3 Code Types</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#button_activators">Button Activators - Info &amp; Digits</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#patch_codes">Patch Codes</a>
</li></ul></li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#encryption">Encryption</a>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#ps2_encryption">Playstation 2 Gameshark Encryption</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#dc_encryption">Sega Dreamcast Encryption</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gba_encryption">Gameboy Advance Encryption</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#xp64_encryption">Xploder/Xplorer N64 &amp; PSX Encryption</a>
</li></ul></li></ul><b>X. <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#the_hacking_begins">How-to Guide - The Hacking Begins</a></b>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#one_small_step_for_man">One Small Step For Man...</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#the_methods">The Methods</a>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#using_game_trainers">Using Game Trainers</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hacking_with_gameshark_pro">Hacking With GameShark Pro - Step by step</a>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#easy_gspro">Hacking The Easy Stuff</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#int_gspro">Hacking The Intermediate Stuff</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hard_gspro">Hacking The Harder Stuff</a>
</li></ul></li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_enablers">Finding N64 Enable Codes</a>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_mtc0">Hacking MTC0 Enablers</a>
<a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_mtc02">MTC0 Enablers An Easier Way</a>
<a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_nonmtc0">Hacking Non-MTC0 Enablers</a>
<a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_ffenablers">Finding 'FF' Enablers</a>
</li></ul></li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_emu">N64 Emulator Based Hacking</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#n64_asm">N64 Assembly ("ASM") Hacking</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hacking_gs33">Hack Your Shark!?</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hacking_ps2_codes">Hacking Playstation 2 Codes</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hacking_dc_codes">Hacking Sega Dreamcast Codes</a>
</li></ul></li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#code_porter">The online Code Porter</a>
</li></ul><b>XI. <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#the_hacking_begins">How-to Guide - Gameboy Hacking</a></b>
<ul><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hacking_with_vba">Hacking Gameboy Advance Codes With Visualboy Advance</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gba_size">Gameboy Advance Size Modifiers How-To</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#hacking_gameboy_advance_enabler_codes">Finding Gameboy Advance Enable Codes</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#ar3_with_arcrypt">Creating AR V3 Codes Using AR Crypt Beta8c</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gba_non_standard_master">Hacking Non-Standard Master Codes</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gba_asm">Gameboy Advance ASM Tutorial</a>
</li><li><a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gameboy_30_hacking">GameBoy 3.0 Hacking - by Curly9od</a>
<ul><b> Section 3 : <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#section_3">Reference</a> </b></ul>
</li></ul>
<b>XIII. <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#downloads">Downloads</a></b>
<b>XIV. <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#gameshark_gameshark_pro_faq">GameShark / GameShark Pro FAQ</a></b>
<b>XV. <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#psx_xplorer_infO">Playstation Xplorer/xploder Information</a></b>
<ul>
<ul><b> Section 4 : <a href="https://macrox.gshi.org/The%20Hacking%20Text.htm#section_4">Legal</a> </b></ul>
</ul>
<hr width="800">
<center><b><font size="+1"><a name="section_1">Section 1 : Foreword</a></font></b></center>
<hr width="800">
-----------------------------------------------
<b><i><font size="+1"><a name="this_version">I) This Version</a></font></i></b>
-----------------------------------------------
Version Number: 5.00c
Release Date: 03-25-2003
Edited by Tolos, Viper and macrox
* = aka Parasyte
-----------------------------------------------
<b><i><font size="+1"><a name="whats_new">II) What's New</a></font></i></b>
-----------------------------------------------
<u>03-02-04</u>
minor update:
-Hacking "unhackable" GBA master codes
-Bitwise Operations info
-A little basic info on using COP1 instructions (N64 ASM)
-IcyGuy revamped his Image Mods and GBA Size Mods info
-MAX Crypt, GCN Crypt, and GCN Code Type Helper downloads added
<u>06-27-03</u>
"Secrets..." goes solely HTML!
-XPloder 7K decryption algorithm
-New AR Crypt info added
-Added PS2 encryptor program (javascript)
-Added Z64 and V64 info in the GameShark FAQ
-Added N64 Emulator Based Hacking guide
-Updated N64 ASM Hacking
-Updated the Downloads section
-More Downloads Added
-Image Modifiers
<u>05-31-03</u>
Tons of new info added:
-codetypes updated/added for all systems
-new N64 enabler information
-More complete Button Activator/Joker info
-New method of hacking N64 Button Activators
-Hacking Timer codes
-Quickstart/Skip Into codes
-CPU &lt;&gt; P2 Control Modifier Codes
-New Moon Jump Method
-X/Y/Z Coordinate Modifiers
-Floating Points info
-Encryption information PS2
-AR Crypt for GBA: Program, V3 code types and guide.
-PS2 hacking
-Info on DC hacking
-Huge N64 ASM Guide
-GBA ASM Hacking tutorial
-GBA Size Mods
-Brought the GS FAQ up-to-date
-Greatly expanded the TOC
-Added a few mini-TOCs in places they'll be useful
<u>05-21-03</u>
Tolos finally manages to pull an update together.
-Added PS2 code type info
-GSA and CBA info
-Added N64 control stick activator info.
-Added links in the Table of Contents for easy refernce (HTML version).
<u>01-01-03</u>
Macrox fixed the errata of missing code types for GS and CB GBA.
<u>05-20-02</u>
Tolos assigned new acting editor by macrox.
-Hacking GameBoy Advance enabler codes
-GameBoy Advance code types
-Added a tidbit on hacking debug codes
-Added a section on hacking GameBoy Advance codes.
<u>11-27-01</u>
Interact Accessories affiliation in legal section removed. Reference to
Gameshark removed from work title. The reader is to Infer the term
gameshark, codebreaker and xplorer to mean cheat device where it occurs
in this work. See legal section for proper credit.
<u>04-21-01</u>
-Revised section on N64 and XP code types
-DC code types and buttons.
-Comparison of GameBoy hacking devices
-Reflashing a GameBoy Shark.
-More on hacking enabler codes and forcing high and low mode res
-DC code types: CodeBreaker, Xplorer and Gameshark.
-How to Hack Speed modifiers.
-Update on Keycodes list
-Revised FAQ section.
<u>11-11-00</u>
-Reflashing a corrupted GameShark
-Info on Pelican's new hack device for Game Boy, "Code Breaker"
-Gameboy hacking info courtesy of Curly9od
<u>05-06-00</u>
-How to hack specific codes section appended
-Using the memory editor has been appended
-How to install the pc hacking utilities, hooking the GameShark
to a PC and upgrading (flashing) the GameShark Rom added.
-How to hack enabler codes
-Hacking walk through walls (WTW) codes
-Link to online code porter (when text viewed online).
<u>07-22-99</u>
-New chapter added - Chapter 4 - GameShark / GameShark Pro FAQ.
-New "How-to" added, for the Big Time Hackers.
-Decimal/Hexadecimal conversion formula added.
-"This Version", "What's New" and "Coming Soon" sections added.
-Many new code type prefixes added.
-----------------------------------------------
<b><i><font size="+1"><a name="coming_soon">III) Coming Soon</a></font></i></b>
-----------------------------------------------
Gamecube Hacking
Caetla Code Types
XP64 Code Types
Saturn Emulator Hacking
CodeBreaker2 Code Types
TBA - To be announced topics.
-----------------------------------------------
<b><i><font size="+1"><a name="dedication">IV) Dedication - by Kong K. Rool</a></font></i></b>
-----------------------------------------------
This document, in all its entirety is dedicated to my dad. A very
brilliant man in the computer/science fields. He passed away July 9th of
1999 at the age of 36. May he rest in peace.
- Kong K. Rool (aka Parasyte)
-----------------------------------------------
<b><i><font size="+1"><a name="preface">V) Preface</a></font></i></b>
-----------------------------------------------
First off I want to say, Macrox has semi-retired from the
hacking scene. That left no one to tend this marvelous document. Then Interact
suddenly stopped hosting GSCentral when they learned that their GameBoy Advance
encryption code had been cracked, and the people at GSCentral were creating
codes that worked with the GameBoy Advance GameShark. After GSCentral came
back, we learned we could not use the word GameShark (TM), or have the Hacking
Text displayed.
So I volunteered to host this document. I hope I can do a
good job; as well as Macrox and Parasyte: that is my aim. I also want to thank
macrox, HyperHacker, and DgenerateKane for helping me along.
Happy hacking,
Tolos (Assigned Editor in Chief)
P.S. The Hacking Text has been re-instated on GSCentral. A mirror copy
of this document will be kept on Tolos<6F> web sites. These are the only officially
endorsed sites by macrox on the most up to date versions of the text.<p></p>
- macrox 1-1-2003 (Editor - retired)
-----------------------------------------------
<b><i><font size="+1"><a name="Acknowledgments">VI) Acknowledgments</a></font></i></b>
-----------------------------------------------
Many talented people have contributed to this work over time either directly or indirectly.
To those people we say thank you for all your contributions to the world of video games and
for hacking codes and sharing ideas on how to hack codes.
People whom have shared ideas and contributed information for this
document:
Kong K. Rool (aka Parasyte)
Macrox <a href="mailto:macrox_the_sage@yahoo.com">macrox_the_sage@yahoo.com</a>
Tolos <a href="mailto:tolos_magician@yahoo.com">tolos_magician@yahoo.com</a>
HyperHacker
DGenerateKane
ShadowKnight
Jim Reinhart (GSCentral Founder)
Code Master
Kamek
Freeza
Subdrag
Viper666(187) <a href="mailto:viper@gscentral.com">viper@gscentral.com</a>
Sutaz
james007
Gold64007
Stinky613
Crocc
Zap2
CodeBoy
Savior
Charizard
Dr. Ian
Curly9od
Bleeding Gums Murphy
Kola
FoxDie
ARHQ - our AR PRO replay affiliates.
Kenobi
Icy Guy
Goldenboy
This list goes on and on, we apologize for any omissions of people who gave of
their time to advance the art. The authors want to thank everyone at GSCentral,
Game Shark Zone, Game Shark (Software) Code Creators Club, Gamasutra, Dextrose,
Interact, MadCatz, and Datel for fruitful discussions.
<hr width="800">
<center><b><font size="+1"><a name="section_2">Section 2 : Hacking</a></font></b></center>
<hr width="800">
-----------------------------------------------
<b><i><font size="+1"><a name="introduction">VII) Introduction</a></font></i></b>
-----------------------------------------------
Welcome to the GameShark World. In this document, you will learn several
different ways to hack your own codes. These methods range in degree of
difficulty from easy to difficult and yield various results. As you read
you are encouraged to practice the methods that are described in this
document. This way, you will learn by your activities.
There is more than one way to hack codes. This ranges from guessing, to
a secret hacking system, which not everyone will understand. Again, as you
read, try the ideas mentioned. It has been proven that people learn easier
and faster when they are active in a project.
It is the authors wish that the material presented here meets the
anticipated needs of the reader's wishes to learn to hack GameShark codes.
You might even come up with another variation of these methods to hack
codes. If you do, let us know and we will consider including it in future
versions of this document.
-----------------------------------------------
<b><i><font size="+1"><a name="hacking_basics">VIII) Hacking Basics</a></font></i></b>
-----------------------------------------------
<b><u><i><a name="know_the_code">A) Know the Code</a></i></u></b>
<b><u><i><a name="offsets">Offsets</a></i></u></b>
Offsets(or RAM addresses) are typically found by examination of the game
memory by using advanced hacking equipment such as a GS Pro, Shark Link or
hex viewer on a ROM. Basically, an offset is a "memory holder" in which
it (usually) holds a byte of memory(a two digit hexadecimal code).
If you find an offset that holds the health digits when using a ROM and
hex viewer, you can be certain that it isn't the GS code(if you find the
health at offset "012203" the GS code usually won't be "80012203 FFFF".)
There is less than a 1% chance of finding an offset and it actually being
the code. The reason the offset and the offset digits in a GS code are not
the same is this - There are MANY, MANY offsets which are used to tell the
platform what type of game it is(size, language, title, checksum values,
etc.), and other operation codes which will assign all the offsets to do
what they are meant to do. There are offsets that hold the hex values that
make up the pictures you see in the game, the coordination's of the character
you control, mathematical operations... The list goes on and on... The
header(tells the machine what type of game you're are booting) might take up
all offsets past "012203" itself!
There is a block of info that tells where the quantifier-offsets(the
byte of memory which you change through GS codes begin and which are usually things
such as number of an item you have or level of health you have). This block is
called RAM(Random Access Memory), which does exactly what it says. RAM is
memory that will be changed all throughout its processing. Score and health
are good examples of RAM, the values for both will be changed while you're
game is running. So think of GameShark as a RAM Editor.
More information about offsets is beyond the scope of this document and
will not be included in future editions of this text.
<b><u><i><a name="systems_of_counting">B) Systems of counting or number base</a></i></u></b>
<b><u><i><a name="decimal">B-1) Decimal</a></i></u></b>
Decimal Notation, based on ten digits, is something you already know.
Count to 50 like you normally count. You can count using decimal notation.
<b><u><i><a name="binary">B-2) Binary</a></i></u></b>
Binary, or dual counting, is based on two digits. It's really easy to
understand and use. You'll need to know the following -
There are two characters used in binary - 0,1
(Think of it as a switch).
A "1" means the switch is turned ON.
A "0" means the switch is turned OFF.
That's what binary is, a bunch of switches. I won't go into any more
detail about switches now, but will return to this topic later in the
document.
A four-digit string of code written in binary is called a "word".(this
is also the same in hex[1-digit])
Four Binary Digits(bits - 'BInary digiTS') equals 1 digit hex.
Three bits equals 1 digit octal.
Now that you know that, hex and octal should seem easier to learn. In
this document, we will refer to any and all hex values with "-h" and decimal
values with "-d". So value "100" decimal will read like this - "100-d" and
"64-h". How do you convert from bits to hex and back? Look at this chart -
Hex Binary Hex Binary
0 - 0000 8 - 1000
1 - 0001 9 - 1001
2 - 0010 A - 1010
3 - 0011 B - 1011
4 - 0100 C - 1100
5 - 0101 D - 1101
6 - 0110 E - 1110
7 - 0111 F - 1111
If you notice, there are no more 4-digit combinations of "0,1" left. Now
for the conversion part. Look at the 4 bits, each of the numbers have a
value assigned to them. We will call these values, "Bit Values".
Number in Hex 6
Number in Binary 0110
Bit Value 8421
(The Bit Value will ALWAYS be this! So remember it!)
You are going to learn to convert by using multiplication. Math is a
great tool to use when working with the GameShark.
You can represent the binary word by letting "0110"(8421) = "IJKL" and
thus you get "1xL + 2xK + 4xJ + 8xI" = "L+2K+4J+8I"(in algebraic terms). Now
substitute the binary back in, you would get "1x0 + 2x1 + 4x1 + 8x0" =
"0+2+4+0" which adds up to six. Six is what the hex value was in the
beginning.
To convert back to binary, use the formula "L+2K+4J+8K", find the
numbers, which add up to six. In this case, "4 and 2". Remember, "IJKL" = the
bit value. Then substitute the binary back in - "1x0 + 2x1 + 4x1 + 8x0" =
"0110".
Why do that when there's an easier way? Because there is no use in
converting when you don't understand why it is done in that way. You will
learn an easier way soon, in fact, make one up!
Octal conversions are the same as hex-to-bit. Only, octal goes up to
"7". So the bit value looks like this -
Octal 3
Binary 011
Bit value 421
The Bit Value will NEVER change. The bit value is actually the value
assigned for each bit. If you have an 8-bit value, the bit value would look
like this -
(128)(64)(32)(16)(8)(4)(2)(1)
Notice that every time a new bit is added(to the beginning, no doubt),
the last bits' value will double. Further explanation is beyond the scope of
this text.
To convert between hex and decimal, use this formula -
yz = 2-digit value hex
(when) z = "A-hex", A = "10-dec"
(when) z = "B-hex", B = "11-dec"
(when) z = "C-hex", C = "12-dec"
(when) z = "D-hex", D = "13-dec"
(when) z = "E-hex", E = "14-dec"
(when) z = "F-hex", F = "15-dec"
(if) z = #, skip next step
z-hex = z-dec, z-dec = q
(if) y = #, skip next step
y-hex = y-dec, y-dec = r
y*6 = s
yz+s = yz-dec
This looks confusing, I know, but I'll explain it as if I were talk to a
10-year-old child.
First, "yz" represents a 2-digit hex value. Our value will be
"64"(y=6, z=4). When "z" is an "A", A equals "10-d". Understand that so far?
If "z"(in the 'yz' hex value) is a number, skip the next step(4 is a number,
so we skip this next step). Transfer "z" to decimal(look at the "when's").
If "y" is a number, skip the next step(6 is also a number, we skip the next
step). Transfer "y" to decimal(look at the "when's"). Multiply value "y"
by 6, the factor is "s". 6*6 = 36, s=36. Add value yz and value s.
64+36 = 100 64-h = 100-d.
Now let's do it short-hand -
"yz" = C8
C = 12, yz = (12)8
12*6 = 72
(12)8 + 72 [7]2 -- 72-d
+(12)8 -- C8-h
------
[20]0 -- 200-d
C8 = 200
If this doesn't make sense, I didn't explain it well enough. It is
important to understand how to do the number base conversions before
continuing. If you do not understand, the reader is encouraged to review the
material already presented.
<b><i><u><a name="bitwisemath">B-3) Bitwise Operations</a></u></i></b>
You may hear about "Bitwise Operators" and wonder what some of them
actually do. They're used for doing binary math, for lack of a better
explanation.
<i><u>&amp; (AND)</u></i>
The AND operation can best be understood like addition.. only there's no
adding or carrying involved... really the only similarity is that you work
with each digit the same as you do with addition...
Like this:
1000
+0001
------
1001
Just add each digit downward. Well, AND requires you to work with each digit
downward as well. Here are the rules:
1 &amp; 1 = 1
1 &amp; 0 = 0
0 &amp; 1 = 0
0 &amp; 0 = 0
That means the result will be a 1 ONLY if both comparing digits are 1
Think of it as true and false.. if TRUE &amp; TRUE, then TRUE.
1100
&amp;1010
------
1000
Starting from the left-most digits, 0 &amp; 0 = 0, 0 &amp; 1 = 0, 1 &amp; 0 = 0,
1 &amp; 1 = 1.... and there's your result.
You can use bitwise AND for a technique called MASKING. Masking allows you to
strip certain bits, while saving others. Say you wanted to strip the upper
nybble of a byte, and save only the lower nybble... Well, you AND that byte
with 00001111b. When you do that, the upper 4 bits will be completely stripped,
because 0 &amp; anything is always equal to 0 and the lower four bits will copied
over directly, because 1 &amp; anything = bits that were set. This can be useful
when dealing with hex numbers as well. Say you have AC1B02FF and you want the
lower four bits for some reason. AC1B32ED AND 0000FFFF = 000032ED
<i><u>| (OR)</u></i>
When using OR, TRUE or anything = TRUE
The rules:
1 OR 1 = 1
1 OR 0 = 1
0 OR 1 = 1
0 OR 0 = 0
OR is used to set bits... whereas AND is used to clear. So, if you wanted to
set the least significant bit, your could do "BYTE OR 00000001"
<i><u>XOR</u></i>
XOR means EXCLUSIVE OR. it's purpose is to inverse bits.
The rules:
1 XOR 1 = 0
1 XOR 0 = 1
0 XOR 1 = 1
0 XOR 0 = 0
Pretty simple here... it works just like OR, with the exception that
1 XOR 1 = 0. Say you have a flag, and you want to toggle it on and off. You
can do "VAR XOR 00000001" and it will inverse it; it will turn it on if it's
off, or it will turn it off if it's on. That's much easier than doing "if VAR =
0 then VAR = 1, else if VAR = 1 then VAR = 0." Just a simple XOR operation and
you're done. Much faster.
<i><u>NOT</u></i>
NOT works EXACTLY like XOR with the mask completely filled with 1's NOT will
inverse the variable completely. All 1's are changed to 0 in the result, and
all 0's are changed to 1 in the result
10101010 XOR 11111111 = 01010101
NOT 10101010 = 01010101
What's the difference?
As you can see, NOT does not have a mask... so you just say "NOT VAR" and you
know it's the same as "VAR XOR 11111111"
The difference could be speed. Especially in assembly, where you might have
to load 0xFFFFFFFF into a register to perform the XOR; you could just do a
simple NOT instead.
Inversing is great because you can negate numbers with it NOT VAR + 1 = -VAR
Take for example...
NOT 00000001 = 11111110
11111110 + 1 = 11111111
and of course, 11111111 = FF, FF is -1
<i><u>&lt;&lt; (Left Shift)</u></i>
Shifting left works like multiplication when you shift left, all right-most
bits get shifted over to the left, and 0's get shifted into the blank spaces.
Here are some examples:
00111111 &lt;&lt; 2 = 11111100
00000001 &lt;&lt; 3 = 00001000
10000000 &lt;&lt; 1 = 00000000
Just shifting digit places. So, shift left by 1 is the same as multiplying by
2, left shift by 2 is the same as multiplying by 4. shift left by 3 is the
same as multiplying by 8, etc. Left shit works best as a means to multiply by
a power of 2. 2^1 = 2, 2^2 = 4, 2^3 = 8, etc. Shift left x is the same as
multiply by 2^x.
<i><u>&gt;&gt; (Right Shift)</u></i>
Right shift works the same, only opposite, so it's like dividing. When right
shifting, bits shifted off of the right side are completely lost, and bits
shifted in from the left come in as 0. Well, they usually shift in as 0 when
right shifting. In MIPS, you may have noticed "Shift Right Arithmetic (SRA)"
and "Shift Right Logical (SRL)." Shifting right logical will ALWAYS shift 0's
into the new spaces. Shifting right arithmetic will shift the MSB (most
signifigant bit) into the new spaces. The MSB is treated as a sign bit with
arithmetic right shift. That's a way to preserve the sign when you divide a
negative number.
Here are some examples...
SRA = Shift Right Arithmetic, SRL = Shift Right Logical:
10000000,00000000,00000000,00000000 SRA 4 =
11111000,00000000,00000000,00000000
10000000,00000000,00000000,00000000 SRL 4 =
00001000,00000000,00000000,00000000
<b><i><u><a name="hexadecimal">B-4) Hexadecimal</a></u></i></b>
Hexadecimal is a programming 'language' you must know in order to hack
GameShark codes. So, what is it? Hex is what your GameShark codes are
written in. There are sixteen characters used in a GS code. The characters
are as follows -
0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F
Let's learn to count in hex. If you look above, you'll see how to count
to fifteen in hex. What's sixteen? "10-h" is sixteen. By the way, don't say
"ten," say, "one, zero" for '10-h'. Let's see what you've learned.
What comes after 19?
What comes after 3F?
If you said, "1A" for question #1, that is correct.
If you said, "40" for question #2, you should know how to count in hex!
<b><u><i><a name="octal">B-5) Octal</a></i></u></b>
Octal is just another way to write binary(like hex), but octal
words are longer than hex words. What you've already read is enough to know
about octal. You do not need to know octal to hack GS codes.
<b><u><i><a name="ascii">B-6) ASCII</a></i></u></b>
ASCII is what you are looking at right now. ANYTHING that can be typed
on the keyboard is ASCII. ASCII is useful to know when hacking in my secret
way. It is also useful for using the text editor search option in hacking
devices such as the GameShark PRO. You don't need to know the assignments for
ASCII characters(although you might need to know them when hacking text editing
codes).
<b><u><i><a name="floatingpoints">B-7) Floating Points</a></i></u></b>
Floating Points are a hexidecimal representation of "real numbers", usually
following the IEEE-754 standard. This could be considered an advanced topic, if
nothing else, because even some long time hackers I've mentioned it to have
never heard of them. However, even those who haven't heard of them, have
most likely dealt with them in one game or another. To put it in the simplest
terms possible: Floating Points are numbers with decimal points. 100.0 and 100
are common values used by games to represent your max health. The difference is
100 is 64 in hex; 100.0 is 42C80000 in hex.
In hacking terms, Floating Points can make it difficult to find some things,
if you're only using 8-Bit comparisons. I'm not saying 32-Bit comparisons are
required though. Most things that use Floating Points are still found by 16-bit
searches.
So how can you convert those hex values like 42C80000 to their decimal form?
This is a question I've been asking for a while now. I'm told it involves advanced
math functions like Shifts and XORs. Don't get worried though. As with most things
that require much thinking, somebody wrote a program to do the conversions for us.
You can get FloatConvert <a href="http://www.gscentral.com/lib/downloads/FloatConvert.zip">here</a>. Nobody really knows who wrote this, but I thank that
person whoever they are.
It's not required you know anything about Floating Points to hack most codes,
but they are a major part of games and certain, more advanced, code types can be
harder to find if don't have a little understanding of this.
<b><u><i><a name="about_most_gameshark_hackers">C) About Most GameShark Hackers</a></i></u></b>
Most hackers use more than one way to hack. Most know programming
languages such as binary/hex/octal, HTML and Perl, scripting languages, R300
Instruction sets, etc. HTML and Perl is included here because many hackers
want to use this language to create a website that has all their codes displayed.
You don't need to learn many of the things other than binary and hexadecimal
to "hack better than the Pros."
Here are some ways you can hack(1 star[*] by the name is easy,
2 is harder, etc.) -
Guessing****
This isn't easy, because you don't always find a code this way.
It's not only troublesome, but risky at some times. Some guessed
codes can corrupt game data and corrupt hacking devices.
Modifying Codes*
One of the easiest things to do. Change a number on an existing
code, you make a new code. (Only works when you have a basis[base
code] to work with.) This technique was and still is widely used.
Looking At The Source[Code]***
Hard, but most effective. Worth a shot. This technique requires the
reader to have a working knowledge of dissembler programs and is
currently beyond the scope of this work.
Using Hacking Equipment* - ***(Code Generators; i.e. GS PRO)
Another way to get codes. It might not be very easy, but it
doesn't take much time. Plus, it's the second most effective way
to hack. Can be used to get easy to hard code types.
Porting**
Porting is taking a code from one version of a game, and making it
work on another version of that same game. This does not always
work. The reason is the same reason that they make more than one
version. Possibly to fix a minor bug. So the offsets will be in a
higher or lower position, or even moved to a totally different
location. You can use the "GS Code Porter"(available at GameShark
Central) to port any code for you. Hence you can make a code
before anyone else gets the chance! See FAQ section.
Combination Hacking* - ***
All you need to do is hack using two or more methods at once, for a
greater chance of finding a code.
(!!!!!There is a slight risk of loosing saved data on your GS
when turning the system on and off while guessing or modifying
codes.)
-----------------------------------------------
<b><i><font size="+1"><a name="how_to_guide">IX) How-to Guide - Getting Started</a></font></i></b>
-----------------------------------------------
<b><u><i><a name="what_do_i_need">A) What do I need?</a></i></u></b>
You need a Game Platform(N64, PSX, Dreamcast, Game Boy, etc.), you need a
game to hack, and you need a GameShark,GameShark PRO or GameShark CDX and/or
other hacking devices such as the Blaze Xplorer/Xploder or Pelican CodeBreaker.
You will also need other things to hack in other ways such as a hex editor and
calculator can do hex math or perhaps an emulator that can capture memory dumps
or can do game saves all of which can be analyzed later by some hex editor
program. A will to learn, basic math skills, patience, endurance, practice and
this using this document are the things you need.
<b><u><i><a name="what_do_I_need_to_know">B) What do I need to Know?</a></i></u></b>
If you've managed to read everything above, then you know about basis of
everything you'll need to know about hacking. The remainder is learning
to use hacking equipment and the software for it and to master the basics as
presented here and then from there to be resolved to try as best you can to
hack the harder code types.
<b><u><i><a name="learn_your_shark">C) Learn Your "Shark" and code types</a></i></u></b>
There are a few things you'll need to know about your GameShark before
we begin hacking. You'll discover how the GameShark codes work.
This is the layout of all N64/PSX 'Shark codes -
XXYYYYYY ZZZZ
This is the layout of all GB 'Shark codes -
XXZZYY-YY This format is called endian. Most Memory ram dumps are
in this format. The GB Gameshark rewrites the code to reversed endian
format as XXZZYYY. The Pelican CodeBreaker uses unencrypted endian format.
The Xploder uses both encrypted and decoded reverse endian formats.
"X" digits is the 'prefix', used to tell the GS what kind of code
you are using.
"Y" digits are the 'Offset Digits', used to locate the offset digits
you want to change.
"Z" digits are the 'Quantity Digits', used to change the quantity of
the chosen offset.
The reason there is a hyphen between the Y's in the GB code layout is
because the Y's are actually set up backwards. The first two Y's should be
behind the second two. Of course, you only need to know this if you are
going to use my hacking method... You ARE going to try it, right?
<b><u>Note:</u></b>
GameShark and Action Replay code types are the same.
<table border="1" cellpadding="7" cellspacing="2" width="700"><tbody><tr><td style="text-align: center;" colspan="3"><nobr><b><i><a name="#n64_code_types">Nintendo 64 Code Types</a></i></b></nobr></td>
<td><nobr>Compatibility</nobr> </td></tr><tr><td><nobr><i>8-bit Constant Write</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Constantly writes the value specified by YY to address XXXXXX.
This and its 16-Bit counterpart below are the most used code types on N64. You'll probably be making
most of your new codes with them. &nbsp;<br>&nbsp;
</td><td rowspan="2">GS/XP64</td></tr><tr><td><nobr>80XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr></nobr></td></tr><tr><td><nobr><i>16-bit Constant Write</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>
Constantly writes the 16-Bit value specified by YYYY to address XXXXXX. &nbsp;<br>&nbsp;
</td><td rowspan="2">GS/XP64</td></tr><tr>
<td><nobr>81XXXXXX YYYY </nobr></td></tr><tr><td><nobr></nobr></td></tr><tr>
<td><nobr><i>8-bit Uncached Write</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Constantly writes the value specified by YY to the uncached address XXXXXX. &nbsp;<br>&nbsp;
</td><td rowspan="2">GS/XP64</td></tr><tr>
<td><nobr>A0XXXXXX 00YY </nobr></td></tr><tr><td><nobr></nobr></td></tr><tr>
<td><nobr><i>16-bit Uncached Write</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Constantly writes the 16-Bit value specified by YYYY to the uncached address XXXXXX. &nbsp;<br>&nbsp;</td><td rowspan="2">GS/XP64</td></tr><tr>
<td><nobr>A1XXXXXX YYYY </nobr></td></tr><tr><td><nobr></nobr></td></tr><tr>
<td><nobr><i>8-bit GS Button</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Writes the value YY to address XXXXXX ONLY when the GS Button is pressed. &nbsp;<br>&nbsp;</td><td rowspan="2">GS/XP64</td></tr><tr>
<td><nobr>88XXXXXX 00YY </nobr></td></tr><tr><td><nobr></nobr></td></tr><tr>
<td><nobr><i>16-bit GS Button</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>16bit version of the above. Writes the value YYYY to address XXXXXX ONLY when the GS Button is pressed. &nbsp;<br>&nbsp;</td><td rowspan="2">GS/XP64</td></tr><tr>
<td><nobr>89XXXXXX YYYY </nobr></td></tr><tr><td><nobr></nobr></td></tr><tr>
<td><nobr><i>8-Bit Equal To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Execute the following code (ZZZZZZZZ ZZZZ) ONLY when the value stored in address XXXXXX is equal to YY. &nbsp;<br>&nbsp;</td><td rowspan="2">GS/XP64</td></tr><tr>
<td><nobr>D0XXXXXX 00YY<br>ZZZZZZZZ ZZZZ<br></nobr></td></tr><tr>
<td><nobr><i>16-Bit Equal To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Same as above, only it reads a 16bit value. GS Pro 3.0+ ONLY! &nbsp;<br>&nbsp;</td><td rowspan="2">GS/XP64</td></tr><tr>
<td><nobr>D1XXXXXX YYYY<br>ZZZZZZZZ ZZZZ<br></nobr></td></tr><tr>
<td><nobr><i>8-Bit Different To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Execute the following code (ZZZZZZZZ ZZZZ) ONLY when the value stored in address XXXXXX is NOT equal to YY. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 3.0+</td></tr><tr>
<td><nobr>D2XXXXXX 00YY<br>ZZZZZZZZ ZZZZ<br></nobr></td></tr><tr>
<td><nobr><i>16-Bit Different To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Same as above, only it reads a 16bit value. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 3.0+</td></tr><tr><td><nobr>D3XXXXXX YYYY<br>ZZZZZZZZ ZZZZ<br></nobr></td></tr><tr>
<td><nobr><i>Disable Expansion Pack</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Keeps the game from using the expansion pack if it is present.
Also used on some older non-expansion pack games to increase compatibility with the code generator. &nbsp;<br>&nbsp;</td><td rowspan="2">GS Pro 3.2+</td></tr><tr>
<td><nobr>EE000000 0000<br></nobr></td></tr><tr>
<td><nobr><i>Disable Expansion Pack</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Disabled the expansion pack (if present) using a secondary method. &nbsp;<br>&nbsp;</td><td rowspan="2">GS Pro 3.2+</td></tr><tr>
<td><nobr>DD000000 0000<br></nobr></td></tr><tr>
<td><nobr><i>Disable Expansion Pack</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Disabled the expansion pack (if present) using a 3rd method. &nbsp;<br>&nbsp;</td><td rowspan="2">GS Pro 3.2+</td></tr><tr>
<td><nobr>CC000000 0000<br></nobr></td></tr><tr>
<td><nobr><i>Enable Code</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Tells the GameShark where the value "3C0880" is in the RAM. This type of code does not write a value to the given address. It sets the entry point which the GS will use to start the game. Games which require that code have a specific protection chip which will set the entry point upon booting the N64. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 1.08+</td></tr><tr>
<td><nobr>DEXXXXXX 0000<br></nobr></td></tr><tr>
<td><nobr><i>Enable Code / 8-Bit Write Once</i>
</nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Tells the GameShark what address is causing malfunction with it, and writes the supplied value to that address.
Writes the value YY to the address XXXXXX once on boot. F0\F1 codes write to RAM before starting the game. This way, the codes take effect before the code handler is executed. &nbsp;<br>&nbsp;</td><td rowspan="2">GS Pro 3.0+ / XP64</td></tr><tr>
<td><nobr>F0XXXXXX 00YY<br></nobr></td></tr><tr>
<td><nobr><i>Enable Code / 16-Bit Write Once</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>16-Bit version of the above. &nbsp;<br>&nbsp;</td><td rowspan="2">GS Pro 3.0+ / XP64</td></tr><tr>
<td><nobr>F1XXXXXX YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Set Store Location For Active Codes</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Sets the location in RAM where active codes are stored. Usually only used on games that utilize the expansion pack. &nbsp;<br>&nbsp;</td><td rowspan="2">GS Pro 3.3+</td></tr><tr>
<td><nobr>FFXXXXXX 0000<br></nobr></td></tr><tr>
<td><nobr><i>Enable Code - Xploder64</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>The same as an F1 enabler on GS Pro. &nbsp;<br>&nbsp;
</td><td rowspan="2">XP64</td></tr><tr>
<td><nobr>2AXXXXXX YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Enable Code - Xploder64</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>The exact use of this code type
is unknown as of now. &nbsp;<br>&nbsp;</td><td rowspan="2">XP64</td></tr><tr>
<td><nobr>3CXXXXXX YYYY<br></nobr></td></tr><tr><td><nobr><i>Patch Code</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>
Patch codes, aka Serial Repeaters, are used to make a code string shorter. EG, You have five codes put together to give you "all weapons." Use the patch to shorten it to two codes.
XX is the number of addresses to write; YY is the amount (offset) to add to each address; ZZ is the amount to add to each value. &nbsp;<br>&nbsp;</td><td rowspan="2">GS Pro 3.3+</td></tr><tr>
<td><nobr>5000XXYY 00ZZ<br>TTTTTTTT VVVV<br></nobr></td></tr></tbody></table>
<table border="1" cellpadding="7" cellspacing="2" width="700"><tbody><tr><td style="text-align: center;" colspan="3"><nobr><b><i><font size="+1"><a name="playstation_code_types">Playstation Code Types</a></font></i></b></nobr> </td><td><nobr>Compatibility</nobr> </td></tr><tr><td colspan="4"><font size="+1"><div align="center">GameShark</div></font></td></tr><tr>
<td><nobr><i>8-bit Constant Write</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Constantly writes the value specified by YY to address XXXXXX. This and its 16-bit counterpart below are the most used code types on PSX. You'll probably be making most of your new codes with them. &nbsp;<br>&nbsp;</td><td rowspan="2">GS x.x</td></tr><tr>
<td><nobr>30XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>16-bit Constant Write</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Constantly writes the value specified by YY to address XXXXXX. This and its 16-bit counterpart below are the most used code types on PSX. You'll probably be making most of your new codes with them. &nbsp;<br>&nbsp;</td><td rowspan="2">GS x.x</td></tr><tr>
<td><nobr>80XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>8-bit Equal To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is equal to the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>E0XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>8-bit Different To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is different to the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>E1XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>8-bit Less Than Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is less than the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>E2XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>8-bit Greater Than Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is greater than the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>E3XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>16-bit Equal To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is equal to the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS x.x</td></tr><tr>
<td><nobr>D0XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>16-bit Different To Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is different to the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>D1XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>16-bit Less Than Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is less than the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>D2XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>16-bit Greater Than Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When the value for the given address is greater than the supplied value, activate the following code. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>D3XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>16-bit Universal Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Same as D0 except not RAM dependent. More easily used as a button activator. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.41+</td></tr><tr>
<td><nobr>D4000000 YYYY </nobr></td></tr><tr>
<td><nobr><i>16-bit All-code Button Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When buttons pressed equal YYYY then activate all codes. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.41+</td></tr><tr>
<td><nobr>D5000000 YYYY </nobr></td></tr><tr>
<td><nobr><i>16-bit Universal De-Activator</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>When buttons pressed equal YYYY then de-activate all codes. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.41+</td></tr><tr>
<td><nobr>D6000000 YYYY </nobr></td></tr><tr>
<td><nobr><i>16-bit Increment Value</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Add value(16-bit) code. Use with D/E activators. Example -<br>(adds value "1007" to address "001221" when address "110012" equals value "5")<br>D0110012 0005<br>10001221 1007 &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>10XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>16-bit Decrement Value</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Subtract value(16-bit) code. Use only with D/E activators. Example -<br>(subtracts value "102" from address "001221" when address "110012" equals value "6")<br>D0110012 0006<br>11001221 0102 &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>11XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>8-bit Increment Value</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Add value(8-bit) code. Use with D/E activators. Example -<br>(adds value "7" to address "001221" when address "110012" equals value "5")<br>D0110012 0005<br>20001221 0007 &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>20XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>8-bit Decrement Value</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Subtract value(8-bit) code. Use only with D/E activators. Example -<br>(subtracts value "2" from address "001221" when address "110012" equals value "6")<br>D0110012 0006<br>21001221 0002 &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>21XXXXXX 00YY </nobr></td></tr><tr>
<td><nobr><i>Patch Code</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Patch codes, aka Serial Repeaters, are used to make a code string shorter. EG, You have five codes put together to give you "all weapons." Use the patch to shorten it to two codes. XX is the number of addresses to write; YY is the amount (offset) to add to each address; ZZ is the amount to add to each value. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.41+</td></tr><tr>
<td><nobr>5000XXYY 00ZZ<br>TTTTTTTT VVVV<br></nobr></td></tr><tr>
<td><nobr><i>Activate All Codes</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Works like the D0/E0 code type, but affects ALL codes. Use as an (M) Must Be On if the game won't load with codes turned on. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.2+</td></tr><tr>
<td><nobr>C0XXXXXX YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Activate All Codes On Delay</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Works like the D0/E0 code type, but affects ALL codes. This is like a timer. A value of around 4000 or 5000 will usually give you a good 20-30 second delay before codes are activated. Use as an (M) Must Be On if the game won't load with codes turned on. &nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.41+</td></tr><tr>
<td><nobr>C1000000 YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Copy Bytes</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Copy's YYYY bytes from location XXXXXX to location ZZZZZZ. <br>Example use would be:<br>C2040450 0008<br>80040680 0000<br>That would copy 8 bytes from 40450 to 40680.<br>&nbsp;<br>&nbsp;</td><td rowspan="2">GS 2.41+</td></tr><tr>
<td><nobr>C2XXXXXX YYYY<br>80ZZZZZZ 0000 </nobr></td>
</tr><tr>
<td colspan="4"><div align="center"><font size="+1">Xplorer/Xploder</font> -- <a name="#psx_xp_code_types">see explorer FAQ for more info</a></div></td></tr><tr>
<td><nobr><i>8-bit Constant Write</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Writes value YY to address XXXXXX. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>30XX XXXX 00YY<br></nobr></td></tr><tr>
<td><nobr><i>16-bit Constant Write</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Writes value YYYY to address XXXXXX. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>80XX XXXX YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Slow Motion Code</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Delays CPU by X per cycle. Best used with activator. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>4000 0000 000X<br></nobr></td></tr><tr>
<td><nobr><i>Text Replace Code</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Writes any number of bytes ZZ to address XXXXXX. YYYY is the number of bytes to write. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>50XX XXXX YYYY<br>ZZZZ ZZZZ ZZZZ<br>ZZZZ ZZ.. ....<br></nobr></td></tr><tr>
<td><nobr><i>Do on Event Code</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>CPU breaks at address AAAAAAAA; YYYY is number of bytes used (XX's); FFFFFFFF is the break point mask; CCCC is the type of break point, which can be E180 (instruction gotton by CPU but not yet implemented), EE80 (data to be read or written), E680 (data to be read), EA80 (data to be wrtten) or EF80 (instruction). &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>6000 0000 YYYY<br>AAAA AAAA CCCC<br>FFFF FFFF XXXX<br>XXXX XXXX XXXX<br></nobr></td></tr><tr>
<td><nobr><i>Do-if-True Code</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>If address XXXXXX is equal to value YYYY execute following code. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>70XX XXXX YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Do-if-False Code</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>If address XXXXXX is not equal to value YYYY execute following code. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>90XX XXXX YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Patch Code</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>nn is the number of repetitions (plus one); AAAA is the size of the address step; BBBB is the increase in the data value per step; XXXXXX is the initial address; YYYY is the inital value. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>B0nn AAAA BBBB<br>10XX XXXX YYYY<br></nobr></td></tr><tr>
<td><nobr><i>Do-if-True Code (c-code)</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Same as 7-code, but only functions from 0010 0000 to 01FF FFFF. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr>
<td><nobr>C0XX XXXX YYYY<br></nobr></td></tr><tr><td><nobr><i>Do-if-True Code (d-code)</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Same as 7-code. but only functions from 0000 0000 to 000F FFFF. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr><td><nobr>D0XX XXXX YYYY<br></nobr>
</td></tr><tr><td><nobr><i>Auto-Activating Code</i></nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>
Automatically activates other selected codes if address XXXXXX is equal to YYYY. &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr><td><nobr>F0XX XXXX YYYY </nobr>
</td></tr><tr><td><nobr><i>32-Bit Constant Write</i></nobr> </td><td colspan="2" rowspan="2">&nbsp;<br>
32-bit constant write to XXXXXX address (0000YYYY) &nbsp;<br>&nbsp;
</td><td rowspan="2">Xplorer</td></tr><tr><td><nobr>00XX XXXX YYYY </nobr>
</td></tr><tr><td><nobr></nobr></td></tr></tbody></table>
<table border="1" cellpadding="7" cellspacing="2" width="700"><tbody><tr><td style="text-align: center;" colspan="2"><nobr><b><i><font size="+1"><a name="PS2_code_types">Playstation 2 Code Types</a> - Courtesy hellion (<a href="http://hellion00.thegfcc.com/">hellion00.thegfcc.com</a>)</font></i></b></nobr></td></tr><tr><td colspan="2"><i>Note that all the code types below are in RAW form. RAW codes must be encrypted to work on the Gameshark<72> for Playstation 2.</i></td></tr><tr><td><nobr><i>8-bit Constant Write</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command will constantly write the value <br>specified by dd to the address specified by aaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>0aaaaaaa 000000dd </nobr></td></tr><tr><td><nobr><i>16-bit Constant Write</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command will constantly write the value <br>specified by dddd to the address specified by aaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>1aaaaaaa 0000dddd </nobr></td></tr><tr><td><nobr><i>32-bit Constant Write</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command will constantly write the value <br>specified by dddddddd to the address specified by aaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>2aaaaaaa dddddddd </nobr></td></tr><tr><td style="text-align: center;" colspan="2"><b>Increment/Decrement Commands</b> </td></tr><tr><td><nobr><i>8-bit Increment</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command adds the value specified by nn to <br>the value stored at the address aaaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>301000nn aaaaaaaa </nobr></td></tr><tr><td><nobr><i>8-bit Decrement</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command subtracts the value specified by nn <br>to the value stored at the address aaaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>302000nn aaaaaaaa </nobr></td></tr><tr><td><nobr><i>16-bit Increment</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command adds the value specified by nnnn to <br>the value stored at the address aaaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>3030nnnn aaaaaaaa </nobr></td></tr><tr><td><nobr><i>16-bit Decrement</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command subtracts the value specified by nnnn <br>to the value stored at the address aaaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>3040nnnn aaaaaaaa </nobr></td></tr><tr><td><nobr><i>32-bit Increment</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command adds the value specified by nnnnnnnn <br>to the value stored at the address aaaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>30500000 aaaaaaaa<br>nnnnnnnn 00000000 </nobr></td></tr><tr><td><nobr><i>32-bit Decrement</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>This command subtracts the value specified by nnnnnnnn <br>to the value stored at the address aaaaaaaa. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>30600000 aaaaaaaa<br>nnnnnnnn 00000000 </nobr></td></tr><tr><td style="text-align: center;" colspan="2"><b>Test Commands</b> </td></tr><tr><td><nobr><i>16-bit Equal</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is equal to the value specified by dddd will the next <br>line of code be executed. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Daaaaaaa 0000dddd </nobr></td></tr><tr><td><nobr><i>16-bit Not Equal</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is not equal to the value specified by dddd will the <br>next line of code be executed. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Daaaaaaa 0010dddd </nobr></td></tr><tr><td><nobr><i>16-bit Less Than</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is less than the value specified by dddd will the next <br>line of code be executed. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Daaaaaaa 0020dddd </nobr></td></tr><tr><td><nobr><i>16-bit Greater Than</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is greater than the value specified by dddd will the <br>next line of code be executed. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Daaaaaaa 0030dddd </nobr></td></tr><tr><td><nobr><i>16-bit Equal : Multiple Skip</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is equal to the value specified by dddd will the next nnn <br>lines of code be
executed. Otherwise, they will be skipped. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Ennndddd 0aaaaaaa </nobr></td></tr><tr><td><nobr><i>16-bit Not Equal : Multiple Skip</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is not equal to the value specified by dddd will the next <br>nnn lines of code be executed. Otherwise, they will be skipped. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Ennndddd 1aaaaaaa </nobr></td></tr><tr><td><nobr><i>16-bit Less Than : Multiple Skip</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is less than the value specified by dddd will the next <br>nnn lines of code be executed. Otherwise, they will be skipped. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Ennndddd 2aaaaaaa </nobr></td></tr><tr><td><nobr><i>16-bit Greater Than : Multiple Skip</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Only when the value at the address specified by aaaaaaa <br>is greater than the value specified by dddd will the next <br>nnn lines of code be executed. Otherwise, they will be skipped. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Ennndddd 3aaaaaaa </nobr></td></tr><tr><td style="text-align: center;" colspan="3"><b>Miscellaneous Commands</b> </td></tr><tr><td><nobr><i>Copy Bytes (GS2 v2.0 or higher)</i><br></nobr></td><td rowspan="2"><br>&nbsp;<br>a = Address to copy from<br>b = Address to copy to<br>n = Number of bytes to copy <br><br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>5aaaaaaa nnnnnnnn<br>bbbbbbbb 00000000<br></nobr></td></tr><tr><td><nobr><i>32-bit Multi-Address Write</i> </nobr></td><td rowspan="2"><br>&nbsp;<br>Starting with the address specified by aaaaaaa, this code will <br>write to xxxx addresses. The next address is determined by <br>incrementing the current address by (yyyy * 4). The value <br>specified by dddddddd is written to each calculated address. Also known as a "Patch Code." <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>4aaaaaaa xxxxyyyy<br>dddddddd 00000000 </nobr><nobr></nobr></td></tr><tr><td colspan="3"><b>Untested Commands</b> </td></tr><tr><td>3000nnnn dddddddd aaaaaaaax(n-1) </td><td>32-bit Multiple Address Write? <br></td></tr><tr><td>8aaaaaaa bbbbbbbb cccccccc 00000000 </td><td>Master Command <br></td></tr><tr><td>Aaaaaaaa dddddddd </td><td>32-bit Write Once? <br></td></tr><tr><td>B0000000 nnnnnnnn </td><td>Timer Command <br></td></tr><tr><td>Caaaaaaa dddddddd </td><td>32-bit Equal? <br></td></tr><tr><td>Faaaaaaa bbbbbbbb </td><td>Master Command <br></td></tr><tr><td>DEADFACE xxxxxxxx</td><td>"DEADFACE" Master Command - changes encryption seeds<br><xmp></xmp></td></tr></tbody></table>
<!-- Begin DC code types ============================================================================== -->
<table border="1" cellpadding="7" cellspacing="1" width="700"><tbody><tr><td style="text-align: center;" colspan="3"><nobr><b><i><font size="+1"><a name="#dc_code_types">Sega Dreamcast Code Types</a></font></i></b></nobr></td></tr><tr><td colspan="3"><i>The following are what decrypted or raw code types look like. Xploder and Codebreaker use this format. Gameshark uses an encrypted format for the first line of the code (the address) while all use the second line as is (offset or quantifier). Dreamcast has 32 bit codes. These codes will require 8 digits for the offset and 8 digits for the quantifier, 2^32= FFFFFFFF in hex. Example, XXYYYYYY ZZZZZZZZ.<br><br><b><u>Note:</u></b> It is not unusual for manufacturers of cheating devices to encrypt their codes. Fire International (Blaze USA) has encrypted codes in both its N64 and Game Boy Xploder/Xplorer, while Interact has employed encryption in its DC Shark, GameBoy Advance Shark, and Playstation 2 Shark. If the code begins with a '0', then it is in decrypted format. As in any encryption there always is a crack to defeat it. Codebreaker and Xploder both have the built in ability to accept DC gameshark codes in decipher them. It is left to the reader to explore the decryption further. </i></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>Code Value</p></font></td><td valign="top" width="76%"><b><font face="Courier New" size="2"></font></b><p><b><font face="Courier New" size="2">Description</font></b></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>00xxxxxx</p><p>000000vv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Write 8bit (byte) value "vv" to memory address 8cxxxxxx. That is, 8 bit constant write.</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>01xxxxxx</p><p>0000vvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Write 16bit (2byte) value "vvvv" to memory address 8cxxxxxx. That is, 16 bit constant write.</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>02xxxxxx</p><p>vvvvvvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Write 32bit (4byte) value "vvvvvvvv" to memory address 8cxxxxxx. That is, 32 bit constant write.</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>0300nnnn</p><p>aaaaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>Group write code. nn specifies how many 32 bit values follow. aaaaaaaa is the addrsss to write to. The values following this code are written to address aaaaaaaa. E.g:</p><p>03000004 </p><p>8c012000</p><p>11111111 </p><p>22222222 </p><p>33333333 </p><p>44444444 </p><p>The effect is as follows: With a count of 00000004 codes, to address 8c012000:</p><p>8c012000 = 11111111</p><p>8c012004 = 22222222</p><p>8c012008 = 33333333</p><p>8c01200c = 44444444</p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>030100vv</p><p>aaaaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Increment code. Add the 8bit value vv to the value at address aaaaaaaa</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>030200vv</p><p>aaaaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Decrement code. Subtract the 8bit value vv from the value at address aaaaaaaa</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>0303vvvv</p><p>aaaaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Increment code. Add the 16bit value vvvv to the value at address aaaaaaaa</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>0304vvvv</p><p>aaaaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Decrement code. Subtract the 16bit value vvvv from the value at address aaaaaaaa</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>03050000</p><p>aaaaaaaa</p><p>vvvvvvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Increment code. Add the 32bit value vvvvvvvv to the value at address aaaaaaaa</font></p><p><font face="Courier New" size="2">Note that this code is 3 lines long and so will require an 0exxxxxx condition (not a 0dxxxxxx) if you're using it with a condition code.</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>03060000</p><p>aaaaaaaa</p><p>vvvvvvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Decrement code. Subtract the 32bit value vvvvvvvv from the value at address aaaaaaaa</font></p><p><font face="Courier New" size="2">Note that this code is 3 lines long and so will require an 0exxxxxx condition (not a 0dxxxxxx) if you're using it with a condition code.</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>04xxxxxx</p><p>rrrrssss </p><p>vvvvvvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>Repeat/Filler code. Writes to address 8Cxxxxxx. Writes the 32bit value vvvvvvvv. Repeats this rrrr time, each time increasing the address by ssss (actually ssss x 4). That is, 32-Bit Constant Serial Write E.g:</p><p>04007a30</p><p>00030001</p><p>12345678 </p><p>Effect: </p><p>8c007a30 = 12345678</p><p>8c007a34 = 12345678</p><p>8c007a38 = 12345678</p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">&nbsp;</font></p><p><font face="Courier New" size="2">05xxxxxx</font></p><p><font face="Courier New" size="2">dddddddd </font></p><p><font face="Courier New" size="2">nnnnnnnn </font></p></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>Copy bytes code. Copy nnnnnnnn bytes from the address 8cxxxxxx to the address dddddddd. That is, constant copy bytes</p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">071000XX </font></p></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">Change Decryption Type</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>0b0xxxxx</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>&nbsp;</p><p>Delay putting on codes for xxxxx cycles.</p><p>Default 1000 (0x3e7)</p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>0cxxxxxx</p><p>vvvvvvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">If the value at address 8Cxxxxxx is equal to vvvvvvvv, execute ALL codes; otherwise no codes are executed. Useful for waiting until game has loaded.</font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>0dxxxxxx</p><p>0000vvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>&nbsp;</p><p>If the value at address 8Cxxxxxx is equal to vvvv, execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code. </p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>0dxxxxxx</p><p>0001vvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>&nbsp;</p><p>If the value at address 8Cxxxxxx is different to vvvv, execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code. </p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>0dxxxxxx</p><p>0002vvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">If the value at address 8Cxxxxxx is less than vvvv (unsigned), execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code. </font></p></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>0dxxxxxx</p><p>0003vvvv</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>&nbsp;</p><p>If the value at address 8Cxxxxxx is greater than vvvv (unsigned), execute the following code. Can be used with code types 00, 01 and 02 only. To use this type of control with other codes use an 0e code. </p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>0ennvvvv</p><p>00aaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">&nbsp;</font></p><p><font face="Courier New" size="2">If the value at address 8caaaaaa is equal to vvvv, execute the following nnnn lines of codes. E.g:</font></p><p><font face="Courier New" size="2">0e04abcd</font></p><p><font face="Courier New" size="2">00012000</font></p><p><font face="Courier New" size="2">02300040</font></p><p><font face="Courier New" size="2">ffffffff</font></p><p><font face="Courier New" size="2">02300050</font></p><p><font face="Courier New" size="2">eeeeeeee</font></p><p><font face="Courier New" size="2">if address 8c012000==abcd, execute the 04 lines of codes following. The 4 lines of codes being two "02xxxxxx" codes "02300040=ffffffff" and "02300050=eeeeeeee".</font></p><font face="Courier New" size="2"></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>0ennvvvv</p><p>01aaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>&nbsp;</p><p>If the value at address 8caaaaaa is different to vvvv, execute the following nnnn lines of codes. </p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>0ennvvvv</p><p>02aaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>&nbsp;</p><p>If the value at address 8caaaaaa is less than vvvv (unsigned), execute the following nnnn lines of codes. </p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"><p>&nbsp;</p><p>0ennvvvv</p><p>03aaaaaa</p></font></td><td valign="top" width="76%"><font face="Courier New" size="2"><p>&nbsp;</p><p>If the value at address 8caaaaaa is greater than vvvv (unsigned), execute the following nnnn lines of codes. </p></font></td></tr><tr><td valign="top" width="24%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">0F-XXXXXX</font></p><p><font face="Courier New" size="2">0000YYYY </font></p></td><td valign="top" width="76%"><font face="Courier New" size="2"></font><p><font face="Courier New" size="2">16-Bit Write Once Immediately. (Activator code)</font></p></td></tr></tbody></table>
<!-- End of DC code types ============================================================================== -->
<table border="1" cellpadding="7" cellspacing="2" width="700"><tbody>
<tr><td style="text-align: center;" colspan="3"><nobr><b><i><font size="+1">
<a name="#ssaturn_code_types">Sega Saturn Code Types</a> - Courtesy Leo/<a href="http://www.agscc.com/">AGSCC</a> and <a href="http://www.cmgsccc.com/">CodeMaster</a></font></i></b>
</nobr></td></tr>
<tr><td><nobr><i>16-bit Constant Write</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Just what it implies. Continuously writes YYYY value to XXXXXXX address. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>1XXXXXXX YYYY </nobr>
</td></tr><tr><td><nobr><i>8-bit Constant Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Continuous write of YY value to address XXXXXXX. &nbsp;<br>&nbsp;
</td></tr><tr><td><nobr>3XXXXXXX 00YY </nobr></td></tr><tr><td><nobr><i>16-bit Write Once</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Writes YYYY value to XXXXXXX address once on boot up. <br> Same as F0/F1 on N64 &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>0XXXXXXX YYYY </nobr>
</td></tr><tr><td><nobr><i>16-bit Equal To Activator</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;
<br>Activates the code on the line directly beneath it ONLY when XXXXXXX address is YYYY value. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>DXXXXXXX YYYY </nobr>
</td></tr><tr><td><nobr><i>16-Bit Enable Code</i> </nobr>
</td><td colspan="2" rowspan="2">&nbsp;<br>Enable Code &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>FXXXXXXX YYYY </nobr>
</td></tr></tbody></table>
<table border="1" cellpadding="7" cellspacing="2" width="700"><tbody><tr><td style="text-align: center;" colspan="3"><nobr><b><i><font size="+1"><a name="#gameboy_code_types">Gameboy/Gameboy Color Code Types</a></font></i></b></nobr></td></tr><tr><td><nobr><i>8-bit Constant Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>The most common GS code prefix for Gameboy is "01". This means the code resides in the first bank of the address line. Codebreaker users will find that 00 and 01 are equally used code types. The "00" simply means the code resides in the zero bank and "01" as above, the first bank. There are no known other code types for gameboy as there are for N64, Playstation and Dreamcast. Z is the data bank; XXXX is the address; YY is the value. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>0ZYYXXXX </nobr></td></tr><tr><td><nobr></nobr></td></tr></tbody></table>
<table border="1" cellpadding="7" cellspacing="2" width="700"><tbody><tr><td style="text-align: center;" colspan="3"><nobr><b><i><font size="+1">
<a name="#gsa_code_types">Gameboy Advance Gameshark V1/V2 Code Types<br> - by Parasyte (Additions by DGenerateKane)</a></font></i></b></nobr></td></tr><tr><td colspan="3"><i>Note that all the code types below are in RAW form. RAW codes must be encrypted to work on the Gameshark for Gameboy Advance.</i></td></tr><tr><td><nobr><i>8-bit Constant Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Continuously writes the value xx to the RAM address aaaaaaa. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>0aaaaaaaa 000000xx </nobr></td></tr><tr><td><nobr><i>16-bit Constant Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Continuously writes the 16-Bit value xxxx to the RAM address aaaaaaa. Address must be aligned to 2 (must end with one of the following digits - 0,2,4,6,8,A,C,E). &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>1aaaaaaaa 0000xxxx </nobr></td></tr><tr><td><nobr><i>32-bit Constant Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Continuously writes the 32-Bit value xxxxxxxx to the RAM address aaaaaaa. Address must be aligned to 4 (must end with one of the following digits - 0,4,8,C). &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>2aaaaaaaa xxxxxxxx </nobr></td></tr><tr><td><nobr><i>32-bit Group Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Writes data to the following "count" (cccc) addresses. (xxxxxxxx value is also concidered an address, not really a problem, just a very stupid bug -- thanks Datel!!) Many addresses can follow. Example: 30000004 01010101 03001FF0 03001FF4 03001FF8 00000000 (write 01010101 to 3 addresses - 01010101, 03001FF0, 03001FF4, and 03001FF8. '00000000' is used for padding, to ensure the last code encrypts correctly) &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>3000cccc xxxxxxxx aaaaaaaa </nobr>
</td></tr><tr><td><nobr><i>16-bit ROM Patch</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>This type allows GSA to
intercept ROM reads and returns the value xxxx. The address is shifted to the right by 1 (divided by 2).
You can either manually shift the address left by 1, or multiply by 2 to get the real address. GSAcrypt
(Win32 version) has an option to automatically shift the address for you. <b>Note:</b> V1\V2 hardware can only have
up to 1 user-defined rom patch max. V3 can have up to 4. some enable code types can shorten the amount of user-defined rom patches available.
&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>6aaaaaaa 0000xxxx </nobr>
</td></tr><tr><td><nobr><i>16-bit ROM Patch</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>
Similar to first ROM patch code, except patch is enabled before the game starts,
instead of waiting for the code handler to enable the patch.
(address &gt;&gt; 1) &nbsp;<br>&nbsp;
</td></tr><tr><td><nobr>6aaaaaaa 1000xxxx </nobr></td></tr><tr><td><nobr><i>16-bit ROM Patch</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>16-bit ROM Patch ? (address &gt;&gt; 1) &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>6aaaaaaa 2000xxxx </nobr></td></tr><tr><td><nobr><i>8-bit GS Button Code</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>8-Bit RAM write only when the GS Button is pressed. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>8a1aaaaa 000000xx </nobr></td></tr><tr><td><nobr><i>16-bit GS Button Code</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>16-Bit RAM write only when the GS Button is pressed. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>8a2aaaaa 000000xx </nobr></td></tr><tr><td><nobr><i>Slowdown On GS Button</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Slow down on GS Button. This type will put the GBA into a loop for "xxxx" number of times, each time the code handler is run. This slows the game down. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>80F00000 0000xxxx </nobr></td></tr><tr><td><nobr><i>16-Bit 'If Equal To' Activator</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Activate the code on the next line ONLY when the value of address 'aaaaaaa' is Equal To xxxx. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Daaaaaaa 0000xxxx </nobr></td></tr><tr><td><nobr><i>16-Bit 'If Equal To' Activator (Multi-Line)</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>16-Bit activate the multi lines if-true. If the value at address is equal to xxxx, execute following 'zz' lines. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>E0zzxxxx aaaaaaaa </nobr></td></tr><tr><td><nobr><i>Hook Routine (For Enablers)</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Used to insert the GS code handler routine where it will be executed at least 20 times per second. Without this code, GSA can not write to RAM.<br><br>xxxx:<br>0001 - Executes code handler without backing up the $lr register. Must turn
GSA off before loading game.<br>0002 - Executes code handler and backs up the $lr register. Must turn GSA off before loading game. <br>0003 - Replaces a 32-bit pointer used for long-branches. Must turn GSA off before loading game. <br>0101 - Executes code handler without backing up the $lr register. <br>0102 - Executes code handler and backs up the $lr register. <br>0103 - Replaces a 32-bit pointer used for long-branches. <br>&nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Faaaaaaa 0000xxxx </nobr></td></tr><tr><td><nobr><i>ID Code (For Enablers)</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Used by GSA only for auto-detecting the inserted game. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>xxxxxxxx 001DC0DE </nobr></td></tr><tr><td><nobr><i>DEADFACE - Change Encryption Seeds</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>"Deadface" is used to change the encryption seeds. It's original intent was probably to re- encrypt codes if someone figured out the normal encryption. (Very similiar to the CBA's '9' code type.) &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>DEADFACE 0000xxxx </nobr></td></tr></tbody></table>
<table border="1" cellpadding="7" cellspacing="2" width="700"><tbody><tr><td style="text-align: center;" colspan="3"><nobr><b><i><font size="+1"><a name="#cba_code_types">Gameboy Advance Codebreaker Code Types<br> - by Parasyte (Additions by DGenerateKane)</a></font></i></b></nobr></td></tr><tr><td colspan="3"><i>Note that all the code types below are in RAW form. RAW codes must be encrypted to work on the Codebreaker for Gameboy Advance.</i></td></tr><tr><td><nobr><i>Master Code #1</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>xxxx is the CRC value (the "Game ID" converted to hex)<br><br>Flags ("yyyy"):<br>0008 - CRC Exists (CRC is used to autodetect the inserted game) <br>0002 - Disable Interupts &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>0000xxxx yyyy </nobr></td></tr><tr><td><nobr><i>Master Code #2</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>'y' is the CBA Code Handler Store Address (0-7) [address = ((d &lt;&lt; 0x16) + 0x08000100)]<br><br. (?xxx=""><br flags="">1000 - 32-bit Long-Branch Type (Thumb) <br>2000 - 32-bit Long-Branch Type (ARM) <br>3000 - 8-bit(?) Long-Branch Type (Thumb)<br>4000 - 8-bit(?) Long-Branch Type (ARM) <br>0020 - Unknown (Odd Effect) <br>&nbsp;<br>&nbsp;</br.></td></tr><tr><td><nobr>1aaaaaaa xxxy </nobr></td></tr><tr><td><nobr><i>8-Bit Constant RAM Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Continuosly writes the 8-Bit value specified by 'yy' to address aaaaaaa. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>3aaaaaaa 00yy </nobr></td></tr><tr><td><nobr><i>Slide Code</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>This is one of those two-line codes. The "yyyy" set is the data to store at the address (aaaaaaa), with xxxxxxxx being the number of addresses to store to, and iiii being the value to increment the addresses by. The codetype is usually use to fill memory with a certain value. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>4aaaaaaa yyyy<br>xxxxxxxx iiii </nobr></td></tr><tr><td><nobr><i>16-Bit Logical AND</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Performs the AND function on the address provided with the value provided. I'm not going to explain what AND does, so if you'd like to know I suggest you see the instruction manual for a graphing calculator. This is another advanced code type you'll probably never need to use. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>6aaaaaaa yyyy </nobr></td></tr><tr><td><nobr><i>16-Bit 'If Equal To' Activator</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>If the value at the specified RAM address (aaaaaaa) is equal to yyyy value, active the code on the next line. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>7aaaaaaa yyyy </nobr></td></tr><tr><td><nobr><i>16-Bit Constant RAM Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Continuosly writes yyyy values to the specified RAM address (aaaaaaa). &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>8aaaaaaa yyyy </nobr></td></tr><tr><td><nobr><i>Change Encryption Seeds<br>(When 1st Code Only!)</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Works like the DEADFACE on GSA. Changes the encryption seeds used for the rest of the codes. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>9yyyyyyy yyyy </nobr></td></tr><tr><td><nobr><i>16-Bit 'If Not Equal' Activator</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>Basicly the opposite of an 'If Equal To' Activator. Activates the code on the next line if address xxxxxxx is NOT equal to yyyy &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>Axxxxxxx yyyy </nobr></td></tr><tr><td><nobr><i>16-Bit Conditional RAM Write</i> </nobr></td><td colspan="2" rowspan="2">&nbsp;<br>No Description available at this time. &nbsp;<br>&nbsp;</td></tr><tr><td><nobr>D00000xx yyyy </nobr></td></tr><tr><td><nobr></nobr></td></tr></tbody></table>
<table border="1" cellpadding="7" cellspacing="2" width="700">
<tbody><tr><td colspan="2" style="text-align: center;"><b><i><font size="+1"><a name="AR_V3_Code_Types">AR V3 Codes Types</a></font></i><font size="+1"></font></b></td></tr>
<tr><td colspan="2" style="text-align: center;"><b>About the Code Types Numbers</b></td></tr>
<tr><td colspan="2"><pre>Let's take for exemple :
Type E3
3.0.3.1.x :
00XXXXXX : (00000130 -&gt; C7000130)
ZZZZZZZZ : Write the Word ZZZZZZZZ to the address $4XXXXXX
3.0.3.1.x :
1st number = 3 = Data size (0 to 3)
2nd number = 0 = Code Type (0 to 7)
3rd number = 3 = Cude subtype (0 to 3)
4th number = 1 = Special bit (0 to 1)
5th number : x = Unused bit (0 to 3)
3.0.3.1.0 gives these (bit speaking) = 11.000.11.1.00
reverse it : 00.1.11.000.11 = 0011100011 = E3 = The code type.
I choose to take this numbering to make it that the Ram 8bits write (Type 0),
Ram 16bits write Type 1 andRam 32bits write (Type 2) have the same type number
than for AR/GS V1/2. Moreover, If I didn't "reverse" the numbers, we've gotten
almost only even code type number, which, IMHO, sounds really strange...
</pre></td></tr>
<tr><td colspan="2" style="text-align: center;"><b>1) Normal RAM Write Codes</b></td></tr>
<tr><td>
Type 00<br>
0.0.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 00224EA4)<br>
Fill area (XXXXXXXX) to (XXXXXXXX+YYYYYY) with Byte ZZ.
</td></tr><tr><td>
XXXXXXXX<br>
YYYYYYZZ
</td></tr>
<tr><td>
Type 01<br>
1.0.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 02224EA4)<br>
Fill area (XXXXXXXX) to (XXXXXXXX+YYYY*2) with Halfword ZZZZ.
</td></tr><tr><td>
XXXXXXXX<br>
YYYYZZZZ
</td></tr>
<tr><td>
Type 02<br>
2.0.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 04224EA4)<br>
Write the Word ZZZZZZZZ to address XXXXXXXX.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td colspan="2" style="text-align: center;"><b>2) Pointer RAM Write Codes</b></td></tr>
<tr><td>
Type 20<br>
0.0.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 40224EA4)<br>
Writes Byte ZZ to ([the address kept in XXXXXXXX]+[YYYYYY]).
</td></tr><tr><td>
XXXXXXXX<br>
YYYYYYZZ
</td></tr>
<tr><td>
Type 21<br>
1.0.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 4224EA4)<br>
Writes Halfword ZZZZ ([the address kept in XXXXXXXX]+[YYYY*2]).
</td></tr><tr><td>
XXXXXXXX<br>
YYYYZZZZ
</td></tr>
<tr><td>
Type 22<br>
2.0.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 4424EA4)<br>
Writes the Word ZZZZZZZZ to [the address kept in XXXXXXXX].
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td colspan="2" style="text-align: center;"><b>3) Add Codes</b></td></tr>
<tr><td>
Type 40<br>
0.0.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 80224EA4)<br>
Add the Byte ZZ to the Byte stored in XXXXXXXX.
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 41<br>
1.0.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 82224EA4)<br>
Add the Halfword ZZZZ to the Halfword stored in XXXXXXXX.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 42<br>
2.0.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 84224EA4)<br>
Add the Word ZZZZ to the Halfword stored in XXXXXXXX.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td colspan="2" style="text-align: center;"><b>4) Write to $4000000 (IO Registers!)</b></td></tr>
<tr><td>
Type 63<br>
3.0.3.0.x
</td><td rowspan="2">
(00000130 -&gt; C6000130)<br>
Write the Halfword ZZZZ to the address $4XXXXXX
</td></tr><tr><td>
00XXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type E3<br>
3.0.3.1.x
</td><td rowspan="2">
(00000130 -&gt; C7000130)<br>
Write the Word ZZZZZZZZ to the address $4XXXXXX
</td></tr><tr><td>
00XXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td colspan="2" style="text-align: center;"><b>5) If Equal Code (= Joker Code)</b></td></tr>
<tr><td>
Type 04<br>
0.1.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 08224EA4)<br>
If Byte at XXXXXXXX = ZZ then execute next code.
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 24<br>
0.1.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 48224EA4)<br>
If Byte at XXXXXXXX = ZZ then execute next 2 codes.
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 44<br>
0.1.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 88224EA4)<br>
If Byte at XXXXXXXX = ZZ execute all the codes below this one in the same row (else execute none of the codes below).
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 64<br>
0.1.3.x.x
</td><td rowspan="2">
(02024EA4 -&gt; C8224EA4)<br>
While Byte at XXXXXXXX &lt;&gt; ZZ turn off all codes.
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 05<br>
1.1.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 0A224EA4)<br>
If Halfword at XXXXXXXX = ZZZZ then execute next code.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 05<br>
1.1.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 0A224EA4)<br>
If Halfword at XXXXXXXX = ZZZZ then execute next code.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 25<br>
1.1.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 4A224EA4)<br>
If Halfword at XXXXXXXX = ZZZZ then execute next 2 codes.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 45<br>
1.1.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 8A224EA4)<br>
If Halfword at XXXXXXXX = ZZZZ execute all the codes below this one in the same row (else execute none of the codes below).
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 65<br>
1.1.3.x.x
</td><td rowspan="2">
(02024EA4 -&gt; CA224EA4)<br>
While Halfword at XXXXXXXX &lt;&gt; ZZZZ turn off all codes.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 06<br>
2.1.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 0C224EA4)<br>
If Word at XXXXXXXX = ZZZZZZZZ then execute next code.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td>
Type 26<br>
2.1.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 4C224EA4)<br>
If Word at XXXXXXXX = ZZZZZZZZ then execute next 2 codes.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td>
Type 46<br>
2.1.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 8C224EA4)<br>
If Word at XXXXXXXX = ZZZZZZZZ execute all the codes below this one in the same row (else execute none of the codes below).
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td>
Type 66<br>
2.1.3.x.x
</td><td rowspan="2">
(02024EA4 -&gt; CC224EA4)<br>
While Word at XXXXXXXX &lt;&gt; ZZZZZZZZ turn off all codes.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td colspan="2" style="text-align: center;"><b>6) If Different Code</b></td></tr>
<tr><td>
Type 08<br>
0.2.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 10224EA4)<br>
If Byte at XXXXXXXX &lt;&gt; ZZ then execute next code.
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 28<br>
0.2.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 50224EA4)<br>
If Byte at XXXXXXXX &lt;&gt; ZZ then execute next 2 codes.
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 48<br>
0.2.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 90224EA4)<br>
If Byte at XXXXXXXX &lt;&gt; ZZ execute all the codes below this one in the same row (else execute none of the codes below).
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 68<br>
0.2.3.x.x
</td><td rowspan="2">
(02024EA4 -&gt; D0224EA4)<br>
While Byte at XXXXXXXX = ZZ turn off all codes.
</td></tr><tr><td>
XXXXXXXX<br>
000000ZZ
</td></tr>
<tr><td>
Type 09<br>
1.2.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 12224EA4)<br>
If Halfword at XXXXXXXX &lt;&gt; ZZZZ then execute next code.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 29<br>
1.2.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 52224EA4)<br>
If Halfword at XXXXXXXX &lt;&gt; ZZZZ then execute next 2 codes.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 49<br>
1.2.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 92224EA4)<br>
If Halfword at XXXXXXXX &lt;&gt; ZZZZ disable all the codes below this one.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 69<br>
1.2.3.x.x
</td><td rowspan="2">
(02024EA4 -&gt; D2224EA4)<br>
While Halfword at XXXXXXXX = ZZZZ turn off all codes.
</td></tr><tr><td>
XXXXXXXX<br>
0000ZZZZ
</td></tr>
<tr><td>
Type 0A<br>
2.2.0.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 14224EA4)<br>
If Word at XXXXXXXX &lt;&gt; ZZZZZZZZ then execute next code.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td>
Type 2A<br>
2.2.1.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 54224EA4)<br>
If Word at XXXXXXXX &lt;&gt; ZZZZZZZZ then execute next 2 codes.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td>
Type 4A<br>
2.2.2.x.x
</td><td rowspan="2">
(02024EA4 -&gt; 94224EA4)<br>
If Word at XXXXXXXX &lt;&gt; ZZZZZZZZ disable all the codes below this one.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td>
Type 6A<br>
2.2.3.x.x
</td><td rowspan="2">
(02024EA4 -&gt; D4224EA4)<br>
While Word at XXXXXXXX = ZZZZZZZZ turn off all codes.
</td></tr><tr><td>
XXXXXXXX<br>
ZZZZZZZZ
</td></tr>
<tr><td colspan="2" style="text-align: center;"><b>7) [If Byte at address XXXXXXXX is lower than ZZ] (signed) Code</b></td></tr>
<tr><td colspan="2">
Signed means :
For bytes : values go from -128 to +127.