   ____
  /    \
 /    / \
i     i  i ALT.
!    *!  ! GAMES.
i________) FAQ!
--Presents--
Super Nintendo/Super Famicom
Game Genie Collection as of
November 26th, 1994. Includes
all Super Nes Game Genie codes
which have ever been published!
Includes code conversion guide.
Game Genie (c) Galoob, Inc 1994


THE COLLECTION IS CONTAINED WITHIN 3 (three) FILES:

1...............AGF-NEW.TXT
                IBM Formatted ASCII text file containing the newest of
                codes which were not in AGF-OLD.TXT

2...............AGF-OLD.TXT
                IBM Formatted ASCII text file containing the old codes
                which have been published in various gaming magazines
                or provided by Galoob.

3...............Game Genie CODE STRUCTURE (this file) explained below.


You may contact me at: evansmj@nextwork.rose-hulman.edu


CODE STRUCTURE:

     The following charts blueprint how to retrieve the bit values
     for the address (memory location to be changed) and data value
     (new number to be in address).  The data value (D) and address
     (A) bit positions that are represented by the code value (C)
     bits (B) are as follows:

                 B5      B4     B3      B2     B1
                 ---     ---    ---     ---    ---
          C1:    D07     D06    D05     D04    D03     (1st Code Char.)
          C2:    D02     D01    D00     A15    A14     (2nd Code Char.)
          C3:    A13     A12    A11     A10    A09     (3rd Code Char.)
          C4:    A08     A23    A22     A21    A20     (4th Code Char.)
          C5:    A19     A18    A17     A16    D12     (5th Code Char.)
          C6:    D11     D10    D09     D08    D15     (6th Code Char.)
          C7:    D14     D13    A07     A06    A05     (7th Code Char.)
          C8:    A04     A03    A02     A01    A00     (8th Code Char.)

          *Table 2:      Position-bit Data/Address-bit content.

     Therefore, the data value (in order) is: 

          (High Byte)             (Low Byte)
          16 15 14 13 12 11 10 09|08 07 06 05 04 03 02 01
          -- -- -- -- -- -- -- --+-- -- -- -- -- -- -- --
          C6 C7 C7 C5 C6 C6 C6 C6|C1 C1 C1 C1 C1 C2 C2 C2
          B1 B5 B4 B1 B5 B4 B3 B2|B5 B4 B3 B2 B1 B5 B4 B3

          *Table 3:      Code position of Data bits.

     Depending on how a program declares its variables, the data
     value may represent one two-byte integer or two one-byte
     numbers located in consecutive memory locations.  When two
     one-byte numbers are represented in a code, usually only one
     of the two numbers is going to be significant and worth
     changing.  In certain cases, only half of one of the bytes (a
     nibble) may contain a value.

     And the address is:

          24 23 22 21 20 19 18 17 (Ultra-high byte)
          -- -- -- -- -- -- -- --
          C4 C4 C4 C4 C5 C5 C5 C5 
          B4 B3 B2 B1 B5 B4 B3 B2 &

          (High byte)             (Low byte)
          16 15 14 13 12 11 10 09|08 07 06 05 04 03 02 01
          -- -- -- -- -- -- -- --+-- -- -- -- -- -- -- --
          C2 C2 C3 C3 C3 C3 C3 C4|C7 C7 C7 C8 C8 C8 C8 C8
          B2 B1 B5 B4 B3 B2 B1 B5|B3 B2 B1 B5 B4 B3 B2 B1

          *Table 4:      Code position of Address bits.

     Note:  Only even addresses are valid, therefore C8B1 is always
     going to contain a '0'.


EXAMPLE:  JURASSIC PARK.

     J3DA-AAG8 : 70 stun gun shots

     First determine which binary values the code characters equal:

          J = 01000
          3 = 11001
          D = 00011
          A = 00000
          -
          A = 00000
          A = 00000
          G = 00110
          8 = 11110

     Next, plug in the values into the Position bit Data/Address bit
     table (Table 2) to find which code character bits correspond to
     which data and address bits.

                         B5     B4      B3     B2      B1
                         ---    ---     ---    ---     ---
          J      C1:     0      1       0      0       0
          3      C2:     1      1       0      0       1
          D      C3:     0      0       0      1       1
          A      C4:     0      0       0      0       0
          A      C5:     0      0       0      0       0
          A      C6:     0      0       0      0       0
          G      C7:     0      0       1      1       0
          8      C8:     1      1       1      1       0

     Next take the bytes and put them into Table 4 to determine the
     address that the code is changing.

          24 23 22 21 20 19 18 17 (Ultra-high byte)
          -- -- -- -- -- -- -- --
          C4 C4 C4 C4 C5 C5 C5 C5 
          B4 B3 B2 B1 B5 B4 B3 B2 &
          == == == == == == == ==
          0  0  0  0  0  0  0  0

          (High byte)             (Low byte)
          16 15 14 13 12 11 10 09|08 07 06 05 04 03 02 01
          -- -- -- -- -- -- -- --+-- -- -- -- -- -- -- --
          C2 C2 C3 C3 C3 C3 C3 C4|C7 C7 C7 C8 C8 C8 C8 C8
          B2 B1 B5 B4 B3 B2 B1 B5|B3 B2 B1 B5 B4 B3 B2 B1
          == == == == == == == ==|== == == == == == == ==
          0  1  0  0  0  1  1  0 |1  1  0  1  1  1  1  0

     When put together (discard leading zeros), the result is
     100011011011110.  Convert this binary value to decimal.
     For example:

      100011011011110=18142(decimal)

     Therefore, the address being changed by code J3DA-AAG8 is
     memory location 18142.

     Determining the data value:

          (High Byte)             (Low Byte)
          16 15 14 13 12 11 10 09|08 07 06 05 04 03 02 01
          -- -- -- -- -- -- -- --|-- -- -- -- -- -- -- --
          C6 C7 C7 C5 C6 C6 C6 C6|C1 C1 C1 C1 C1 C2 C2 C2
          B1 B5 B4 B1 B5 B4 B3 B2|B5 B4 B3 B2 B1 B5 B4 B3
          == == == == == == == ==|== == == == == == == ==     
          0  0  0  0  0  0  0  0 |0  1  0  0  0  1  1  0

     The data value (in binary) is 1000110.  Now we convert this
     to decimal:

            |  |  |  |  |  |             
            |  |  |  |  |  |            
            |  |  |  |  |  |               64
           6| 3| 1|  |  |  |                4
           4| 2| 6| 8| 4| 2| 1          +   2
          --+--+--+--+--+--+--          ------
           1  0  0  0  1  1  0  =          70

     70 is the data value (and the number of stun gun shots).
     This code modifies a counter in location 18142(decimal)

CODE WORKSHEET:

     Game:  ________________________________________________

     Effect:  ______________________________________________

     Code bits:

                         B5 | B4 | B3 | B2 | B1
                         ---+----+----+----+---
          ( )    C1:        |    |    |    |
                         ---+----+----+----+---
          ( )    C2:        |    |    |    |
                         ---+----+----+----+---
          ( )    C3:        |    |    |    |
                         ---+----+----+----+---
          ( )    C4:        |    |    |    |
                         ---+----+----+----+---
          ( )    C5:        |    |    |    |
                         ---+----+----+----+---
          ( )    C6:        |    |    |    |
                         ---+----+----+----+---
          ( )    C7:        |    |    |    |
                         ---+----+----+----+---
          ( )    C8:        |    |    |    |


     Address Value:

          24 23 22 21 20 19 18 17 (Ultra-high byte)
          -- -- -- -- -- -- -- --
          C4 C4 C4 C4 C5 C5 C5 C5 
          B4 B3 B2 B1 B5 B4 B3 B2 &
          == == == == == == == ==
                                

          (High byte)             (Low byte)
          16 15 14 13 12 11 10 09|08 07 06 05 04 03 02 01
          -- -- -- -- -- -- -- --+-- -- -- -- -- -- -- --
          C2 C2 C3 C3 C3 C3 C3 C4|C7 C7 C7 C8 C8 C8 C8 C8
          B2 B1 B5 B4 B3 B2 B1 B5|B3 B2 B1 B5 B4 B3 B2 B1
          == == == == == == == ==|== == == == == == == ==
                                 |


          Address = _________________

     Data Value:

          (High Byte)             (Low Byte)
          16 15 14 13 12 11 10 09|08 07 06 05 04 03 02 01
          -- -- -- -- -- -- -- --|-- -- -- -- -- -- -- --
          C6 C7 C7 C5 C6 C6 C6 C6|C1 C1 C1 C1 C1 C2 C2 C2
          B1 B5 B4 B1 B5 B4 B3 B2|B5 B4 B3 B2 B1 B5 B4 B3
          == == == == == == == ==|== == == == == == == ==     
                                 |                      

          High = _______________   Low = __________________

          Long = __________________________________________

