Seiken Densetsu 2 / Secret of Mana

Seiken Densetsu 2 / Secret of Mana

RAM Map

ROM Map

The ROM Map describes various offsets, some could be broken down further and just haven't been expanded up on, but data structures are provided for those linked to.

Data Tables

Audio Waveforms

Audio Tracks

Items

Item Prices / アイテムの値段

Each item price is 2 bytes long, little endian.

Color Palettes

Each item price is 0x1D (29) bytes long. This chart is missing most entries.

Store Inventory / 店データ

The list of goods in each store varies with the last entry being 0xFF to indicate the end.

Experience to Level Up

This is the experience required to level up, 3 bytes long with 99 entries.

0-2: Experience Level Required
0-2:レベルアップ必要経験値

Armors

Values 0x00 - 0x14 are head wear, values 0x15 - 0x29 are body wear and 0x2A - 0x3F are for the arms.

                                |

Monsters

Weapon List

Magic List

Menu Icons

They are 96 bytes each, the first 48 of which contain the icon text. In VRAM, the range is from DC00 - DFFF. The routine that loads the icons into RAM is at D0CA8B - D0CAB6.

Data Structures

Monster / NPC Location

Each object is 16 bytes, and the number of objects is dependent on the locations.

 1 - Spawn Type (?)
 2 - ?
 3 - ?
 4 - ?
 5 - ?
 6 - ?
 7 - ?
 8 - ?
 9 - ?
10 - ?
11 - Starting X-Coordinate
12 - Starting Y-Coordinate
13 - Palette - Z-Plane (?)
14 - Sprite
15 - Reaction to Button Press
16 - Reaction to Button Press

Map Entrances & Exits

Each entry is 4 bytes long.

1  Destination
2  Destination X-Coordinate
3  Destination Y-Coordinate
4  Destination Entrance Style

Weapons Data

Each weapon block takes up 12 bytes, and there are 190 weapons blocks.

$00  Graphic 1 (?)
$01  Bits 7-6: Raises Agility               (00: 0, 01: +1, 10: +5, 11: -5)
     Bits 5-4: Raises Health (Constitution) (00: 0, 01: +1, 10: +5, 11: -5)
     Bits 3-2: Raises Intelligence          (00: 0, 01: +1, 10: +5, 11: -5)
     Bits 1-0: Raises Wisdom                (00: 0, 01: +1, 10: +5, 11: -5)
$02  Bits 1-0: Raises Strength              (00: 0, 01: +1, 10: +5, 11: -5)
$03  Graphic 1 (2)
$04  Color Palette
$05  Bit 7: Effective Against Dragons
     Bit 6: Effective Against Ghosts
     Bit 5: Effective Against Evil / Dead
     Bit 4: Effective Against Slimes / Lizards
     Bit 3: Effective Against Animals / Birds / Beasts
     Bit 2: Effective Against Insects
     Bit 1: Effective Against Plants / Fish
     Bit 0: Effective Against Sub-Human (?)
$06  Critical Rate (0x00 - 0xFF, 100% at 0xFF)
$07  Hit% (0x00 - 0x64)
$08  Attack
$09  Bit 7: Cause Confusion
     Bit 6: Cause Petrify
     Bit 5: Cause Frozen / Frostied
     Bit 4: Cause Stun
     Bit 3: Cause ?
     Bit 2: Cause 'Slowed Down'
     Bit 1: Cause ?
     Bit 0: Cause ?
$10  Bit 7: Cause Death
     Bit 6: Cause Fire / Englufed
     Bit 5: Cause Poison
     Bit 4: Cause Moogled
     Bit 3: Cause Transform
     Bit 2: Cause Barrel
     Bit 1: Cause Midget / Pygmized
     Bit 0: Cause Balloon
$11  Additional Effect from Abnormal Condition % (0x00 - 0x64)

 0  グラフィック？１
 1  b7-6:すばやさ補正 （00:なし, 01:+1, 10:+5, 11:-5）
    b5-4:たいりょく補正 （00:なし, 01:+1, 10:+5, 11:-5）
    b3-2:ちせい補正 （00:なし, 01:+1, 10:+5, 11:-5）
    b1-0:せいしん補正 （00:なし, 01:+1, 10:+5, 11:-5）
 2  b1-0:ちから補正 （00:なし, 01:+1, 10:+5, 11:-5）
 3  グラフィック？２
 4  カラーパレット
 5  b7:相性○ ドラゴン系
    b6:相性○ ゴースト系
    b5:相性○ アンデッド・アクマ系
    b4:相性○ スライム系・リザード系
    b3:相性○ どうぶつ・トリ・獣人系
    b2:相性○ ムシ系・カラダのかたい
    b1:相性○ しょくぶつ・サカナ系
    b0:相性○ 亜人系
 6  クリティカル率 （00 ～ FFh、 FFhで100%）
 7  ヒット％（0～64h）
 8  攻撃力
 9  b7:付加効果 混乱
    b6:付加効果 石化
    b5:付加効果 雪だるま
    b4:付加効果 気絶
    b3:付加効果 ？
    b2:付加効果 おもり
    b1:付加効果 ？
    b0:付加効果 ？
10  b7:付加効果 死神
    b6:付加効果 火だるま
    b5:付加効果 毒
    b4:付加効果 モーグリ
    b3:付加効果 変身
    b2:付加効果 タル
    b1:付加効果 ちびっ子
    b0:付加効果 風船
11  付加効果による状態異常発生％（0～64h）

Monster Structure

The monster structure is 16 bytes long, with 128 monster spots available.

$00 - $03  Graphic
$04        Shadow Pattern
$05 - $08  Animation
$09        Initial Action (Combination of algorithm behavior, locks up)
$10        Algorithm Behavior
$11 - $15  Animation

0-3  : グラフィック
4    : 影パターン
5-8  : アニメーション
9    : 初期行動 （行動アルゴリズムとの組み合わせによっては 、固まってしまう
10   : 行動アルゴリズム
11-15: アニメーション

Monster Data

Each monster entries takes up 29 bytes, and there are 128 entries.

00       Level
01 - 02  HP
03       MP
04       Strength (0x00 - 0x64)
05       Agility (0x00 - 0x64)
06       Intelligence (0x00 - 0x64, related to Magic Attack from Sprite)
07       Wisdom (0x00 - 0x64, related to Magic Attack Power)
08       Evade Percent (0x00 - 0x64)
09 - 10  Defence (0x00 - 0x3E7)
11       Magic Evade % (0x00 - 0x64) まほうかいひ％（0～64h）
12 - 13  Defence (0x00 - 0x3E7)
14  Bit 7: Race Dragons
    Bit 6: Race Ghosts
    Bit 5: Race Evil / Dead
    Bit 4: Race Slimes / Lizards
    Bit 3: Race Animals / Birds / Beasts
    Bit 2: Race Insects
    Bit 1: Race Plants / Fish
    Bit 0: Race Sub-Human (?)
15  Bit 7: Weakness: Luna / Moon
    Bit 6: Weakness: Gnome / Tree
    Bit 5: Weakness: Shade / Dark
    Bit 4: Weakness: Lumina / Light
    Bit 3: Weakness: Undine / Water
    Bit 2: Weakness: Salamando / Fire
    Bit 1: Weakness: Dryad / Mana
    Bit 0: Weakness: Sylphid / Wind
16 - 17  Experience
18       Unknown
19       Unknown
20  Bit 7: Tolerance Confusion
    Bit 6: Tolerance Petrify
    Bit 5: Tolerance Frozen / Frostied
    Bit 4: Tolerance Stun
    Bit 3: Tolerance ?
    Bit 2: Tolerance 'Slowed Down'
    Bit 1: Tolerance ?
    Bit 0: Tolerance ?
21  Bit 7: Tolerance Death
    Bit 6: Tolerance Fire / Englufed
    Bit 5: Tolerance Poison
    Bit 4: Tolerance Moogled
    Bit 3: Tolerance Transform
    Bit 2: Tolerance Barrel
    Bit 1: Tolerance Midget / Pygmized
    Bit 0: Tolerance Balloon
22       Unknown
23       Short Range Weapon
24       Long Range Weapon
25       Death Animation
26  Bits 7-4: Magic Level (0 - 9)
    Bits 3-0: Weapon Level (0 - 9)
27 - 28  Bulk

  0: レベル
1-2: HP
3: MP
4: ちから（0～64h）
5: すばやさ（0～64h）
6: ちせい（0～64h、ポポイ用の魔法攻撃力に関係する）
7: せいしん（0～64h、プリム用の魔法攻撃力に関係する）
8: かいひ％（0～64h）
9-10: ぼうぎょ（0～3E7h）
11: まほうかいひ％（0～64h）
12-13: 魔法防御（0～3E7h）
14: b7: 種族 ドラゴン系
    b6: 種族 ゴースト系
    b5: 種族 アンデッド・アクマ系
    b4: 種族 スライム系・リザード系
    b3: 種族 どうぶつ・トリ・獣人系
    b2: 種族 ムシ系・カラダのかたい
    b1: 種族 しょくぶつ・サカナ系
    b0: 種族 亜人系
15: b7: 弱点 月
    b6: 弱点 木
    b5: 弱点 闇
    b4: 弱点 聖
    b3: 弱点 水
    b2: 弱点 火
    b1: 弱点 土
    b0: 弱点 風
16-17: 経験値
18:（未解析）
19:（未解析）
20: b7:耐性 混乱
    b6:耐性 石化
    b5:耐性 雪だるま
    b4:耐性 気絶
    b3:耐性 ？
    b2:耐性 おもり
    b1:耐性 ？
    b0:耐性 ？
21: b7:耐性 死神
    b6:耐性 火だるま
    b5:耐性 毒
    b4:耐性 モーグリ
    b3:耐性 変身
    b2:耐性 タル
    b1:耐性 ちびっ子
    b0:耐性 風船
22: （未解析）
23: 武器１
24: 武器２
25: 死亡時アニメーション
26: b7-4:魔法レベル（0～9）
    b3-0:武器レベル（0～9）
27 - 28: ルク

Magic Data

Each magic entry is 40 bytes long, and there are 42 entries. Magic at level 8 is more reliable at level 9.

Track:
  0: Direct
  1: Pursuit (Air Blast, Energy Ball)
  2: Pursuit (Sabre System)
  5: From Above (Thunderbolt)
  6: (Baguru ?) (Saint-beam)
  7: From Above (Frozen)

00       Unknown
01       Unknown
02       Graphics Set for Regular Magic 1
03       Graphics Set for Regular Magic 2
04       Graphics Set for Super Magic 1
05       Graphics Set for Super Magic 2
06       Graphics Set for Unknown Magic 1
07       Graphics Set for Unknown Magic 2
08       Level 0/1 (Unexplained)
09       Level 0/1 Track
10 - 15  Level 0/1 Effects Animation
16       Level 2/3 (Unexplained)
17       Level 2/3 Track
18 - 23  Level 2/3 Effects Animation
24       Level 4/5 (Unexplained)
25       Level 4/5 Track
26 - 31  Level 4/5 Effects Animation
32       Level 6/7 (Unexplained)
33       Level 6/7 Track
34 - 39  Level 6/7 Effects Animation
40       Super Magic (Unexplained)
41       Super Magic Track
42 - 47  Super Magic Effects Animation
48       Over Level 10 (?) (Unexplained)
49       Over Level 10 (?) Track
50 - 55  Over Level 10 (?) Effects Animation
56  Bit 7: Can Select Enemy Object
    Bit 6: Can Select Boy Equipped with the Sword
    Bit 5: Can Select Orb
    Bit 0: Double Single (0: Single Target, 1 Multiple Targets)
57  Unknown
58  Effect Size (?)
59  Unknown
60  Bit 7: Attribute: Dryad
    Bit 6: Attribute: Luna
    Bit 5: Attribute: Lumina
    Bit 4: Attribute: Shade
    Bit 3: Attribute: Salamando
    Bit 2: Attribute: Undine
    Bit 1: Attribute: Sylphid
    Bit 0: Attribtue: Gnome
61  Bit 7: Additional Effect Confusion
    Bit 6: Additional Effect Petrify
    Bit 5: Additional Effect Frozen / Frostied
    Bit 4: Additional Effect Stun
    Bit 3: Additional Effect ?
    Bit 2: Additional Effect 'Slowed Down'
    Bit 1: Additional Effect ?
    Bit 0: Additional Effect ?
62  Bit 7: Additional Effect Death
    Bit 6: Additional Effect Fire / Englufed
    Bit 5: Additional Effect Poison
    Bit 4: Additional Effect Moogled
    Bit 3: Additional Effect Transform
    Bit 2: Additional Effect Barrel
    Bit 1: Additional Effect Midget / Pygmized
    Bit 0: Additional Effect Balloon
63  MP Consumption

※超魔法はLv8で稀に、Lv9で確実に発動する魔法の強力バージョン。
※軌道 0:対象に直接
       1:追尾（エアブラスト、エナジーボール）
       2:追尾（セイバー系）
       5:上から（サンダーボルト）
       6:基本的にバグる（セイントビーム）
       7:上から（フリーズ）
 ------------------------
 0:？
 1:？
 2:通常魔法のグラフィックセット１
 3:通常魔法のグラフィックセット２
 4:超魔法のグラフィックセット１
 5:超魔法のグラフィックセット２
 6:（？のグラフィックセット１）
 7:（？のグラフィックセット２）
 8:Lv0/1 （未解明）
 9:Lv0/1 軌道
10-15:Lv0/1 エフェクトアニメーション
16:Lv2/3 （未解明）
17:Lv2/3 軌道
18-23:Lv2/3 エフェクトアニメーション
24:Lv4/5 （未解明）
25:Lv4/5 軌道
26-31:Lv4/5 エフェクトアニメーション
32:Lv6/7 （未解明）
33:Lv6/7 軌道
34-39:Lv6/7 エフェクトアニメーション
40:超魔法 （未解明）
41:超魔法 軌道
42-47:超魔法 エフェクトアニメーション
48:Lv10以上？ （未解明）
49:Lv10以上？ 軌道
50-55:Lv10以上？ エフェクトアニメーション
56:b7:対象 敵
   b6:対象 剣を装備したランディ
   b5:対象 宝箱・クリスタルオーブも選択可
   b0:対象 単／複（0:単体のみ, 1:単複選択可能）
57:？
58:効果量？
59:？
60:b7:属性 木
  :b6:属性 月
  :b5:属性 聖
  :b4:属性 闇
  :b3:属性 火
  :b2:属性 水
  :b1:属性 風
  :b0:属性 土
61:b7:追加効果/セイバー効果 混乱
   b6:追加効果/セイバー効果 石化
   b5:追加効果/セイバー効果 雪だるま
   b4:追加効果/セイバー効果 気絶
   b3:追加効果/セイバー効果 ？
   b2:追加効果/セイバー効果 おもり
   b1:追加効果/セイバー効果 ？
   b0:追加効果/セイバー効果 ？
62:b7:追加効果/セイバー効果 死神
   b6:追加効果/セイバー効果 火だるま
   b5:追加効果/セイバー効果 毒
   b4:追加効果/セイバー効果 モーグリ
   b3:追加効果/セイバー効果 変身
   b2:追加効果/セイバー効果 タル
   b1:追加効果/セイバー効果 ちびっ子
   b0:追加効果/セイバー効果 風船
63:消費MP

Monster Treasure Chest Drop Items / モンスターが落とす宝箱

Each entry is 5 bytes long, with 128 entries.

0  Bit  7:
     0x1:    Chest Runs Away From You
     0x0:    Chest Stands Still
   Bits 6:   If set chest always appears. Overrides Probability.
   Bits 5-0: Chest Probability (0x00 - 0x64). `percentage = (value&0x1F) / 64.0;`
1  Trap information
   Type of trap is based depends on the level of the Monster.
   Bits 4-7: Agility needed to avoid trap `if( ((value&0xF0)>>1) < agility ) avoidTrap();`
   Bits 0-3: Analyze magic level needed to defuse trap
2  Money / Item & Probability for a Rare Drop
   Bit 0-2: Ignored (Unknown?)
   Bit 3-5: Probability for a rare drop. `percentage = ((value&0x38)>>3) / 64.0;`
   Bit 6:   Content of the Normal Drop
     0x0: Money
     0x1: Item
   Bit 7:   Content of the Rare Drop
     0x0: Item
     0x1: Money
3  Amount of Money / Item ID
     0x01-0x3E = Equipment
     0x40-0x50 = Items
     0x80      = Talon Orb works up to 9
     0x81      = Probably Sword Orb, but Candy always appears
     0x82      = Axe Orb up to 9
     0x83      = Lance Orb up to 9
     0x84      = Whip Orb up to 9
     0x85      = Bow Orb up to 9
     0x86      = Boomerang Orb up to 9
     0x87      = Javelin Orb up to 9
     0x88-     = Candy
4  Rare Drop Money Amount / Rare Drop Item ID
     Same as byte 0x3

**Deprecated translation, needs update**
0:b7:宝箱が逃げるか（0:逃げない,1:逃げる）
  b6-b0:宝箱出現確率（0～64h）
1:罠の確率？（罠の種類はモンスターのレベルによって変わる）
2:アイテム／ルク（宝箱の中身がアイテムかルクか、を決める。法則はよく分からず。）
3:宝箱の中身（コモン）
4:宝箱の中身（レア）

Armor Data / 防具データ

Each entry is 10 bytes long, with 62 entries.

0  Bit 4: +5 to Strength
   Bit 3: +5 to Agility
   Bit 2: +5 to Constitution
   Bit 1: +5 to Intelligence
   Bit 0: +5 to Wisdom
1  Defence
2  Evasion
3  Magic Defence
4  Magic Evasion
5  Bit 7: Boy Can Wear
   Bit 6: Girl Can Wear
   Bit 5: Sprite Can Wear
6  (?)
7  Bit 7: Resistance against Confusion
   Bit 6: Resistance against Petrify
   Bit 5: Resistance against Frozen / Frostied
   Bit 4: Resistance against Stun
   Bit 3: Resistance against ?
   Bit 2: Resistance against 'Slowed Down'
   Bit 1: Resistance against ?
   Bit 0: Resistance against ?
8  Bit 7: Resistance against Death
   Bit 6: Resistance against Fire / Englufed
   Bit 5: Resistance against Poison
   Bit 4: Resistance against Moogled
   Bit 3: Resistance against Transform
   Bit 2: Resistance against Barrel
   Bit 1: Resistance against Midget / Pygmized
   Bit 0: Resistance against Balloon
9  (?)

0: b4: ちから+5
   b3: すばやさ+5
   b2: たいりょく+5
   b1: ちせい+5
   b0: せいしん+5
1: 防御力
2: 回避率
3: 魔法防御
4: 魔法回避率
5: b7: ランディ装備可能
   b6: プリム装備可能
   b5: ポポイ装備可能
6: ？
7: b7: 耐性 混乱
   b6: 耐性 石化
   b5: 耐性 雪だるま
   b4: 耐性 気絶
   b3: 耐性 ？
   b2: 耐性 おもり
   b1: 耐性 ？
   b0: 耐性 ？
8: b7: 耐性 死神
   b6: 耐性 火だるま
   b5: 耐性 毒
   b4: 耐性 モーグリ
   b3: 耐性 変身
   b2: 耐性 タル
   b1: 耐性 ちびっ子
   b0: 耐性 風船
9: ？

Item Data / アイテムデータ

Each entry is 16 bytes long, with 12 entries.

 0: ?
 1: ?
 2: Amount to Recover
 3: ?
 4: ?
 5: ?
 6: ?
 7: Effect 1
 8: Effect 2
 9: Effect 3
10: Effect 4
11: Effect 5
12: Effect 6
13: Effect 1
14: ?
15: ?

 0: ？
 1: ？
 2: 回復量
 3: ？
 4: ？
 5: ？
 6: ？
 7: エフェクト１
 8: エフェクト２
 9: エフェクト３
10: エフェクト４
11: エフェクト５
12: エフェクト６
13: エフェクト７
14: ？
15: ？

Character Level Stats Data

Each entry is 8 bytes long, with 99 entries per character, so (8 * 99) * 3.

0-1: HP
  2: MP
  3: Strength
  4: Agility
  5: Constitution
  6: Intelligence
  7: Wisdom

0-1: HP
  2: MP
  3: ちから
  4: すばやさ
  5: たいりょく
  6: ちせい
  7: せいしん

SPC Header / SPC ヘッダ

The SPC header is 26 bytes long.

00-01 : Sequence Size                 シーケンスの大きさ
02-03 : Sequence Starting Address     シーケンス開始アドレス
04-05 : Channel 1 Starting Address    Channel 1開始アドレス
06-07 : Channel 2 Starting Address    Channel 2開始アドレス
08-09 : Channel 3 Starting Address    Channel 3開始アドレス
0A-0B : Channel 4 Starting Address    Channel 4開始アドレス
0C-0D : Channel 5 Starting Address    Channel 5開始アドレス
0E-0F : Channel 6 Starting Address    Channel 6開始アドレス
10-11 : Channel 7 Starting Address    Channel 7開始アドレス
12-13 : Channel 8 Starting Address    Channel 8開始アドレス
14-15 : Sequence Ending Address + 1   シーケンス終了アドレス + 1

SPC Sequence Commands

00-0E = Play Note: C
0F-1D = Play Note: C#
1E-2C = Play Note: D
2D-3B = Play Note: D#
3C-4A = Play Note: E
4B-59 = Play Note: F

5A-68 = Play Note: F#
69-77 = Play Note: G
78-86 = Play Note: G#
87-95 = Play Note: A
96-A4 = Play Note: A#
A5-B3 = Play Note: B
B4-C2 = Continue previous note for given length (There is no B# -- it's the same as C)
C3-D1 = Rest

Each note has 15 different values for their length.
The relative lengths for C (00-0E) are:
00 = 64
01 = 48
02 = 32
03 = 21.333
04 = 24
05 = 16
06 = 10.66
07 = 12
08 = 8
09 = 5.333
0A = 4
0B = 2.666
0C = 2
0D = 1.333
0E = 1

D2 xx       = Set instrument volume to xx
D3 xx       = ???
D4 xx       = Pan channel left or right [$00 = Right, $64 = Middle, $FF = Left] (Reverse stereo)
D7 ss tt dd = Vibrato: ss = Speed, tt = Time until vibrato, dd = Depth
E0          = Vibrato off?
E1          = ???
E2          = ???
E3          = ???
E4 xx       = Change pitch (octave) to xx
E5          = Increases the pitch (octave)
E5 xx       = Length of next note is xx
E6          = Decreases the pitch (octave)
EA xx       = Change Instrument to xx
F0 xx yy    = Starts a loop pattern and the parameter is the number of iterations it will loop for.
              They can be nested. It's used for music "compression."
F1          = End Loop
F2          = End of channel
F3 xx       = Change tempo to xx
F4          = ???
F5 xx       = Set reverb to xx
F6          = ???
F7 xx yy    = ???
F8 xx       = Set global SPC volume to xx
F9          = ??? (Looping Command)
FF          = End of Sequence (?)

Sequences & control codes should be mostly compatible with Final Fantasy 5, interchanging tracks between the two should be easy.
シーケンス、 制御コード、 共にFF5との互換性が強く、 容易に相互移植が可能だと思われる。

BRR Samples

SPC Songs

Compression

Seiken Densetsu 2 Graphic Compression / 聖剣伝説2 タイトル系圧縮

The game uses a LZ style compression for most data types. A working reference decompressor is available here as well as an example of the input and output:
Secret_of_Mana_Decompressor.rb Secret_of_Mana_Title_Screen_Compressed.gfx Secret_of_Mana_Title_Screen_Decompressed.gfx

Data Structure / データ構造

$01-$02  Type of Compression (014C00 + X)
         #  : Type
         00 : 0x1F
         01 : 0x0F
         02 : 0x07
         03 : 0x03
         04 : 0x01
         05 : 0x00
$03-$04  Size of Uncompressed Data (Big Endian)
$05-~    First byte of Compressed Data

1-2 バイト目 : 圧縮の種類 (014C00 + X)
　  [数値:圧縮の数値]
   00 : 0x1F
   01 : 0x0F
   02 : 0x07
   03 : 0x03
   04 : 0x01
   05 : 0x00
3-4 バイト目 : 解凍後の大きさ(ビッグエンディアン)
5-~ バイト目 : 圧縮部分

Compression Code List / 圧縮コード一覧

XX YY ZZ ...

XX = 0x00-0x7F (Single Byte Code XX / XX の 1 バイトコード)

The XX is the length of raw data to read starting at the next byte, (XX + 1).
その後の ROM データを (XX + 1) バイト参照する．

XX = 0x80-0xFF (2-byte Code XX YY / XX YY の 2 バイトコード)

{ (XX - 0x80) AND (Compression Type) } × 0x100 + (YY + 1) is the position of where to read from. This position is how many bytes back from the current position. To calculate the actual position from the start you would subtract this value from the current position.
[ (XX - 0x80) / (Compression Type + 1)] + 3 is the length of the data to read.
{ (XX - 0x80) AND (圧縮の数値) } × 0x100 + (YY + 1) バイト前のメモリーから
[ (XX - 0x80) / (圧縮の数値+1)] + 3 バイト分参照する

Compression Priority, Prediction / 圧縮優先度 / 予想

1. 0x80-0xFF
2. 0x00-0x7F

Seiken Densetsu 2 Boss Graphic Compression

The game handles boss sprites in the following way:

1. Read pointers for compressed tiles.
2. Write compressed data from ROM via blockmove to WRAM.
3. Decompress and directly write them with $2118/$2119 in VRAM.

Read Boss Tile Data

$C2/260C BF 52 BC D0 LDA $D0BC52,x[$D0:BC8A] A:0038 X:0038 Y:001A P:envmxdIzc
$C2/2610 85 95       STA $95    [$00:0295]   A:00DB X:0038 Y:001A P:envmxdIzc
$C2/2612 85 9D       STA $9D    [$00:029D]   A:00DB X:0038 Y:001A P:envmxdIzc
$C2/2614 BF 54 BC D0 LDA $D0BC54,x[$D0:BC8C] A:00DB X:0038 Y:001A P:envmxdIzc
$C2/2618 85 97       STA $97    [$00:0297]   A:8E86 X:0038 Y:001A P:eNvmxdIzc
$C2/261A BF 56 BC D0 LDA $D0BC56,x[$D0:BC8E] A:8E86 X:0038 Y:001A P:eNvmxdIzc
$C2/261E 85 99       STA $99    [$00:0299]   A:6200 X:0038 Y:001A P:envmxdIzc
$C2/2620 BF 58 BC D0 LDA $D0BC58,x[$D0:BC90] A:6200 X:0038 Y:001A P:envmxdIzc
$C2/2624 85 9B       STA $9B    [$00:029B]   A:1400 X:0038 Y:001A P:envmxdIzc
$C2/2626 A0 00 60    LDY #$6000              A:1400 X:0038 Y:001A P:envmxdIzc
$C2/2629 A6 97       LDX $97    [$00:0297]   A:1400 X:0038 Y:6000 P:envmxdIzc
$C2/262B A9 7F 00    LDA #$007F              A:1400 X:8E86 Y:6000 P:eNvmxdIzc

Decompression starts at $C2/2636. Decrompression:

public class DecompBoss {

    int now, last, code, decompByte;
    int[] data;
    int[] decomp;

    public void setData(int[] data){
        this.data = data;
    }

    public void decomp(int length){
        decomp = new int[length];
        now = 0;
        last = 0;
        decompByte = 0;
        for(int dataByte=0; data.length > dataByte; dataByte++){
            code = data[dataByte];
            System.out.println("Decompress code: " + code);
            for(int counter = 0;counter < 8; counter++){
                code = code * 2;
                if(code > 255){
                    dataByte++;
                    code = code-256;
                    decomp[decompByte] = data[dataByte];
                    last = now;
                    now = data[dataByte];
                }
                else{
                    decomp[decompByte] = last;
                    last = now;
                    now = decomp[decompByte];
                }
                decompByte++;
            }
        }
    }

    public void out(){
        System.out.println(" ");
        for(int x=0; decomp.length > x; x++){
            if(x % 16 == 0){
                System.out.println(" ");
            }
            System.out.print(Integer.toHexString(decomp[x])+" ");
        }
        System.out.println(" ");
    }
}

Examples

Example: 5B (Length)

0B 01 03 01 FF 06 02 0D 04 1B 08 16 01 C2 00 00
01 FF 02 01 04 03 08 07 00 0F FF 1E 00 F3 12 86
84 26 04 8F F6 16 E4 12 E0 FF 00 00 12 0C 84 78
04 F8 03 00 FC 4B 00 0F 11 07 FF 33 0F 79 39 63
20 EF 6F C3 00 00 0E 0F F9 1F 1F 07 3F 1F 7F CA
00 00 E0 58 F7 14 A0 CA F0 D0 E6 68

Uncompressed:

00 00 00 00 01 00 03 01 06 02 0D 04 1B 08 16 01
00 00 00 00 00 00 01 00 02 01 04 03 08 07 00 0F
1E 00 F3 12 86 84 26 04 F6 04 F6 04 16 E4 12 E0
00 00 12 0C 84 78 04 F8 04 F8 04 F8 04 F8 00 FC
00 00 00 00 0F 00 11 07 33 0F 79 39 63 20 EF 6F
00 00 00 00 00 00 0E 0F 1F 1F 07 3F 1F 3F 1F 7F
00 00 00 00 E0 00 58 00 14 A0 CA F0 CA D0 E6 68

2B
(  ) E0E0           (F0) F8F8FCFC
(EF) 0F0073801FFF03 (E0) 030000
(17) 0F7F0303       (C0) 0000
(BF) FCC70419E1C6F8 (FF)E37C791E190E0906

000000000000E0E0 F8F8FCFCFCFCFCFC
0F007300801FFF03 0300000000000000
0000000F007F0303 0000000000000000
FC00C70419E1C6F8 E37C791E190E0906

---------------------------------

2C
(  ) 04F801FEC0FF (FF) 607F181F080F0007
(6F) 0080C0806040 (FE) 30209810CC0084
(8B) 00804080     (FD) 20C010E000F0F8

000004F801FEC0FF 607F181F080F0007
00008000C0806040 30209810CC008400
0000000080004080 20C010E000F000F8

---------------------------------

05
(2F) 183E182706

0000000000000000 0000000000000000
0000000000000000 0000000000000000
0000000000000000 000018003E182706

Seiken Densetsu 2 Map Compression / 聖剣伝説2 マップ圧縮

This describe the compression used on maps.

Data Structure / データ構造

$00  1st byte   = (Numbers in 1st byte / 2) + 1 = Horizontal Size
$01  2nd byte   = (Numbers in 2nd byte / 2) + 1 = Vertical Size
$02  3rd byte ~ = Compressed Data

$00  1バイト目  = [1 バイト目の数値 / 2] + 1 = "横の大きさ"
$01  2バイト目  = [2 バイト目の数値 / 2] + 1 = "縦の大きさ"
$02  3バイト目- = 圧縮部分

Compression Code List / 圧縮コード一覧

XX YY ZZ ...

XX = 0x00-0xBF (Single Byte Code XX / XX の 1 バイトコード)

Simply outputs the value of XX. XX の値をそのまま書き込む

XX = 0xC0-0xDF (Single Byte Code XX / XX の 1 バイトコード)

Bits 3-4 of XX + 1 are the number of bytes of memory before.
Bits 0-2 of XX + 1 are the byte write.
("XX の bit3-4" + 1) バイト前のメモリーの数値を
("XX の bit0-2" + 1) バイト書き込む

XX = 0xE0 (2-byte Code XX YY / XX YY の 2 バイトコード)

{ ("Bit 7 of YY" + 1 ) × 0x80 } previous bytes from memory, ("Bits 0-6 of YY" + 1) are bytes to reference.
{ ("YY の bit7" + 1 ) × 0x80 } バイト前のメモリーから, ("YY の bit0-6" + 1) バイト参照する

XX = 0xE1-0xE7 (Single Byte Code XX / XX の 1 バイトコード)

0x80 previous bytes from memory, ("Bits 0-2 of XX" + 1) are bytes to reference.
0x80 バイト前のメモリーから, ("XX の bit0-2" + 1) バイト参照する

XX = 0xE8-0xEF (2-byte Code XX YY / XX YY の 2 バイトコード)

{ ("Bits 0-2 of XX") × 2 + "Bit 7 of YY" + 1 } previous bytes from memory, ("Bits 0-6 of YY" + 1) are bytes to reference.
{ ("XX の bit0-2") × 2 + "YY の bit7" + 1 } バイト前のメモリーから, ("YY の bit0-6" + 1) バイト参照する．

XX = 0xF0 (2-byte Code XX YY / XX YY の 2 バイトコード)

This code will vary depending on the value of YY.

YY < 0x80

0x01 previous bytes of memory, incrementing by 1, ("Bits 0-6 of YY" + 1) bytes to write.
Example: [0x60] 61 62 63 64 65 66 67 68 69 ... and so on. For a length of 10, so 10 consecutive in total.
0x01 バイト前のメモリーの数値を, 1 ずつ加算しながら, ("YY の bit0-6" + 1) バイト書き込む．
(60 / 61 62 63 64 65 66 67 68 69 ...など．計10連続以上の場合)

YY ≥ 0x80

0x01 previous bytes of memory, decrementing by 1, ("Bits 0-6 of YY" + 1) bytes to write.
Example: [0x5C] 5B 5A 59 ... and so on. For a length of 3, so 3 consecutive in total.
0x01 バイト前のメモリーの数値を, 1 ずつ減算しながら, ("YY の bit0-6" + 1) バイト書き込む．
(5C / 5B 5A 59 ... など．計3連続以上の場合)

XX = 0xF1-0xF7 (Single Byte Code XX / XX の 1 バイトコード)

0x01 previous bytes of memory, incrementing by 1, ("Bits 0-2 of XX" + 1) bytes to write.
Example: [0x60] 61 62 ... and so on. 2 ~ 9 consecutive times in total.
0x01 バイト前のメモリーの数値を, 1 ずつ加算しながら, ("XX の bit0-2" + 1) バイト書き込む．
(60/61 62 ...等に使われる．計2～9連続の場合)

XX = 0xF8-0xFF

Unknown
Rarely Used? / 滅多に使われない?

Compression Priority, Prediction / 圧縮優先度 / 予想

1. 0xC0-0xEF - The most efficient, if this isn't efficient go to 2. / のうち 最も効率がいいもの (効率がよくない場合は下へ)
2. 0xF0-0xF7 - The most efficient, if this isn't efficient go to 3. / のうち 最も効率がいいもの (効率がよくない場合は下へ)
3. 0x00-0xBF - Direct Write / の直値書き込み

Raw Format Parsing

This is a less systematic way of doing what the code above does.
Symbol (prevByteN) indicates the value of a byte processed in the past. For (N=1), the last byte before this command; (N=2), the byte before (N=1); and so on. These work based on the decompressed results of past commands, not the compressed commands themselves. N is a decimal value.
The first two bytes of a map specify width and height, respectively. To convert them to real values, divide each byte by two and add one.
Map data is pointed to from a table at D0200.

Compression Codes

For the following codes XX = 7F or XX = FF will fill 128 bytes.

For the following codes:

• XX = 7F or XX = FF will fill 128 bytes.
• XX = 00-7F: use the lower prevByteN value (odd values)
• XX = 80-FF: use the higher prevByteN value (even values)

Important Note: These functions can and will collide with themselves. Take, say, E8 02; it repeats prevByte1, and then hits itself. So it gets prevByte1 again, and hits itself again... this isn't an infinite loop due to the behavior of the argument - after XX + 1 (in this case, 3) bytes, it stops dead. Pretty nifty.

The first value filled for all of these codes is (prevByte1 + 1).

If the codes breach the width value of the map, the following tiles are placed automatically on the next line; auto-wrap, in a sense.

Errors in Decompression

These are known errors in the postulated compression scheme above (mismatches between WRAM and prediction).

Tileset 16x16 Compression

16x16 Tileset Compression Commands

  00  Copy Last Tile Entirely
  01  8-bit Increment on Tile Index Value of Last Tile
  10  8-bit Decrement on Tile Index Value of Last Tile

1111 XXXXXXXX XXXXXXXX  Specify entire tile data
 110 XXXXXXX:           Add 7-bit signed value XXXXXXX to previous tile's tile index,
                        and use that
1110 XXXX YYYYYY        Change tile flags with XXXX as follows,
                        and add 6-bit signed value YYYYYY to previous tile's tile index.

0PPP: Change Palette to PPP
1FFF: Change Flags:
        Vertical Flip
        Horizontal Flip
        Alt. BG

Icon Compression

The compression is nothing special really. The ratio of compressed to decompressed data is always 3:4. Basically each sprite tile consists of 0x18 bytes, which can be divided into 3 byte subsections. When I look at 4BPP graphics in a hex editor, to me the most intuitive way is to view each 8 pixel line as a square. Luckily the developers at Squaresoft shared my point of view so it was fairly easy to understand what they were doing. Demonstration using random hex values:

$000000: FF 7F 0F 07 FF 7F 0F 07 FF 7F 0F 07 FF 7F 0F 07
$000010: 3F 1F 03 01 3F 1F 03 01 3F 1F 03 01 3F 1F 03 01

For simplicity's sake, #$XX will refer to a literal value, whereas $XX will refer to a memory location with the given address.

The first line of the image data is determined by the values at $00, $01, $10, and $11. The next line is determined by that of $02, $03, $12, and $13. If you look at the example above you can see that each line is therefore a 2 byte by 2 byte square.

Suppose we wanted the color index of the first (top left pixel). We'll take {FF 7F, 3F 1F} and examine the left most bit (MSB) of each byte. With #$FF the left most bit has value 1. With #$7F the MSB is 0, same for #$3F and #$1F. Thus the color index for the top left pixel is 1. Why? The MSB of $00 corresponds to bit zero of the color index, the MSB of $01 corresponds to bit one of the color index, the MSB of $10 ... corresponds to bit two of the color index. We can then see that the color index for the next pixel to the right would be 1 + (1 << 1) + (0 << 2) + (0 << 3) = 3. (Note: instead of using the MSB, for the second pixel we use the next bit to the right. For the third pixel you use the next bit to the right after that, and so on.)

Now what if each line always looked like this:

XX YY
ZZ 00

Where the letters are arbitrary bits, but the fourth byte is always zero. This effectively reduces the size of the tile's colors to 3BPP (ranging from 0 to 7). But that leaves lots of redundant space, so why not compress the data into 3 byte chunks instead of 4 byte chunks? That's exactly what Squaresoft did, but they made it a little more complicated.

They store it in a 3BPP format with color indices ranging from 0 to 6. 7 corresponds to 0 before any addition is done ( that's coming up). They made it more complicated by making some of the sprites have all their indices increase by 0, 5, or A, depending on the sprite. Why would you do this? It's easy to see - Tiles of the first type use the color 0 (transparent) and colors 1 through 6. Tiles of the next type use the color 0, and colors 5 through B, the last type uses the color 0, and colors A through F. Thus you only need one palette entry (16 colors) to handle three different kinds of sprites. Very economical, b/c you can not only save space on graphics by compressing them in the rom, you can partition a palette entry as well.

Anyways, when I did my decompression routine, I ignored the possibility that the finished product might have 5 or A added to all its indices. Why? Because the relationship between all the color values would stay the same, and thus still be recognizable in the tile editor. In the rom the tiles are stored in a neutral format that doesn't really know if it has 0, 5, or A added to them later, so it doesn't really matter.

I know I'm rambling quite a bit, but here's a diagram of what happens:

Sample compressed first line of a tile: FF F0 F0.

First what happens is this gets written to the rectangular grid:

FF F0
F0 00

Then we go through each pixel, starting from left to right, and calculate the color index. The color indices going from left to right should be 7, 7, 7, 7, 1, 1, 1, 1

The decompression algorithm asks us to change 7's into zeroes. Anything else gets left alone. The result:

0F 00
00 00

Recompressing is simply changing sevens back into zeroes, then ignoring the fourth byte and packing it back into three byte segments. The LSR, ROL, ASL crap is basically an algorithm that does that. It's probably not the cleanest way to do it. If I were writing code to handle this, I think I'd probably use TSB and TRB and what not.

Deccompression / Recompression Code

// Small program designed to simply load/save icon graphics from Secret of Mana
// Psuedo C Code
unsigned char data[0x4200];
unsigned char output[0x5800];
unsigned char comp[0x80];
unsigned char uncomp[0x80];
unsigned char carry = 0;
unsigned char a_reg = 0;
unsigned char nextcarry = 0;

int counter = 0;
int offset = 0;
int tile = 0;
int loop = 0;
int sprite = 0;

void decompress(){
  for(tile = 0; sprite < 0xB0 ; sprite++){
    offset = 0x60 * sprite;

    // This for loop grabs the compressed data for the four tiles of the current sprite.
    for(counter = 0; counter < 0x80 ; counter += 2, offset += 3){
      comp[counter]        = data[offset];
      comp[counter + 1]    = data[offset + 1];
      comp[counter + 0x10] = data[offset + 2];
      comp[counter + 0x11] = 0;

      tile += 2;

      if(tile == 0x10){
        tile = 0;
        counter += 0x10;
      }
    }

    tile = 0;
                // This for loop does a number of manuevers to decompress the data.
    for(counter = 0; counter < 0x80 ; counter += 2){
      loop = 8;

      loopback:

      a_reg = 0;
      carry = 0;

      // ASL $10, X; {
      carry = (comp[counter + 0x10] & 0x80) ? 1 : 0;
      comp[counter + 0x10] <<= 1;
      //}

      // ROL A; {
      nextcarry = (a_reg & 0x80) ? 1 : 0;
      a_reg = (a_reg << 1) + carry;
      carry = nextcarry;
      //}

      // ASL $01, X; {
      carry = (comp[counter + 1] & 0x80) ? 1 : 0;
      comp[counter + 1] <<= 1;
      //}

      // ROL A; {
      nextcarry = (a_reg & 0x80) ? 1 : 0;
      a_reg = (a_reg << 1) + carry;
      carry = nextcarry;
      //}

      // ASL $00, X; {
      carry = (comp[counter] & 0x80) ? 1 : 0;
      comp[counter] <<= 1;
      //}

      // ROL A; {
      nextcarry = (a_reg & 0x80) ? 1 : 0;
      a_reg = (a_reg << 1) + carry;
      carry = nextcarry;
      //}

      if(a_reg == 0x07){
        a_reg = 0;
      }
      else{
        carry = 0;
      }

      // Now decompress the tiles into the uncomp buffer
      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      // ROL $20, X; {
      nextcarry = (uncomp[counter] & 0x80) ? 1 : 0;
      uncomp[counter] = (uncomp[counter] << 1) + carry;
      carry = nextcarry;
      //}

      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      // ROL $21, X; {
      nextcarry = (uncomp[counter + 1] & 0x80) ? 1 : 0;
      uncomp[counter + 1] = (uncomp[counter + 1] << 1) + carry;
      carry = nextcarry;
      //}

      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      // ROL $30, X; {
      nextcarry = (uncomp[counter + 0x10] & 0x80) ? 1 : 0;
      uncomp[counter + 0x10] = (uncomp[counter + 0x10] << 1) + carry;
      carry = nextcarry;
      //}

      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      // ROL $31, X; {
      nextcarry = (uncomp[counter + 0x11] & 0x80) ? 1 : 0;
      uncomp[counter + 0x11] = (uncomp[counter + 0x11] << 1) + carry;
      carry = nextcarry;
      //}

      loop--;

      if(loop > 0){
        goto loopback;
      }

      tile += 2;

      if(tile == 0x10){
        tile = 0;
        counter += 0x10;
      }
    }
    memcpy(output + (sprite * 0x80), uncomp, 0x80);
  }
  // Write output to file, 0x5800 bytes in size.
}

void recompress(){
  // Now to save import the graphics into the rom. Working in the 0x5800 buffer now.
  for(sprite = 0; sprite < 0xB0; sprite++){
    offset = (sprite * 0x80);

    memcpy(uncomp, output + offset, 0x80);

    a_reg = 0;
    carry = 0;

    for(counter = 0; counter < 0x80; counter += 2){
      loop = 8;

      loopback2:

      // LSR $31, X; {
      nextcarry = (uncomp[counter + 0x11] & 0x01) ? 1 : 0;
      uncomp[counter + 0x11] >>= 1;
      carry = nextcarry;
      //}

      // ROL A; {
      nextcarry = (a_reg & 0x80) ? 1 : 0;
      a_reg = (a_reg << 1) + carry;
      carry = nextcarry;
      //}

      // LSR $30, X; {
      nextcarry = (uncomp[counter + 0x10] & 0x01) ? 1 : 0;
      uncomp[counter + 0x10] >>= 1;
      carry = nextcarry;
      //}

      // ROL A; {
      nextcarry = (a_reg & 0x80) ? 1 : 0;
      a_reg = (a_reg << 1) + carry;
      carry = nextcarry;
      //}

      // LSR $21, X; {
      nextcarry = (uncomp[counter + 1] & 0x01) ? 1 : 0;
      uncomp[counter + 1] >>= 1;
      carry = nextcarry;
      //}

      // ROL A; {
      nextcarry = (a_reg & 0x80) ? 1 : 0;
      a_reg = (a_reg << 1) + carry;
      carry = nextcarry;
      //}

      // LSR $20, X; {
      nextcarry = (uncomp[counter] & 0x01) ? 1 : 0;
      uncomp[counter] >>= 1;
      carry = nextcarry;
      //}

      // ROL A; {
      nextcarry = (a_reg & 0x80) ? 1 : 0;
      a_reg = (a_reg << 1) + carry;
      carry = nextcarry;
      //}

      if(a_reg == 0){
        a_reg = 7;
      }

      // Now start putting things back into the "compressed" buffer.
      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      // ROR $00, X; {
      nextcarry = (comp[counter] & 0x01) ? 1 : 0;
      comp[counter] >>= 1;
      comp[counter] |= (carry << 7);
      carry = nextcarry;
      //}

      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      // ROR $01, X; {
      nextcarry = (comp[counter + 1] & 0x01) ? 1 : 0;
      comp[counter + 1] >>= 1;
      comp[counter + 1] |= (carry << 7);
      carry = nextcarry;
      //}

      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      // ROR $10, X; {
      nextcarry = (comp[counter + 0x10] & 0x01) ? 1 : 0;
      comp[counter + 0x10] >>= 1;
      comp[counter + 0x10] |= (carry << 7);
      carry = nextcarry;
      //}

      // LSR A; {
      carry = (a_reg & 0x01) ? 1 : 0;
      a_reg >>= 1;
      //}

      loop--;

      if(loop > 0){
        goto loopback2;
      }

      tile += 2;

      if(tile == 0x10){
        tile = 0;
        counter += 0x10;
      }
    }

    tile = 0;

    offset = (sprite * 0x60);

    for(counter = 0; counter < 0x80; counter += 2, offset += 3){
      data[offset]     = comp[counter];
      data[offset + 1] = comp[counter + 1];
      data[offset + 2] = comp[counter + 0x10];

      tile += 2;

      if(tile == 0x10){
        tile = 0, counter += 0x10;
      }
    }
  }
  // Write the data buffer to the ROM file at 0x128400, 0x4200 bytes overwritten.
}

Text

Script Pointers

C90000 contains the first 1024 script pointers (based from C90000) and CA0000 contains the remaining pointers, for a total of 2561. There are only 2048 scripts, the rest are texts used in status screens etc.

Script Commands

Translations

This is a translation of the spells, items, equipment, and locations.

Locations

Weapons

Headgear

Armor

Armwear

Items

Elementals

Spells

Monsters

Bosses

Event Data / イベントコード

1F 01  プリムの仲間加入時の名前を決める&武器のグローブ入手（プリム初期装備）
2B 01  プリム加入
1F 02  ポポイの仲間加入時の名前を決める&武器のブーメラン入手（ポポイ初期装備）
2B 02  ポポイ加入
24 1B  全回復
1F 06  現在地でセーブ（表示上はポトス村セーブになる）

Item Storage

Check Item Count

$D0/D9B9 4A LSR A A:0040 X:0000 Y:0000 P:envmxdIzc
$D0/D9BA 4A LSR A A:0020 X:0000 Y:0000 P:envmxdIzc
$D0/D9BB 4A LSR A A:0010 X:0000 Y:0000 P:envmxdIzc
$D0/D9BC 4A LSR A A:0008 X:0000 Y:0000 P:envmxdIzc
$D0/D9BD 4A LSR A A:0004 X:0000 Y:0000 P:envmxdIzc
$D0/D9BE 60 RTS   A:0002 X:0000 Y:0000 P:envmxdIzc

Buying Allowed (Less Than 4 Items):

$C0/6552 BF 00 CC 7E LDA $7ECC00,x[$7E:CC49] A:0000 X:0049 Y:0001 P:envMxdIZC
$C0/6556 18          CLC                     A:0060 X:0049 Y:0001 P:envMxdIzC
$C0/6557 69 20       ADC #$20                A:0060 X:0049 Y:0001 P:envMxdIzc
$C0/6559 C9 9F       CMP #$9F                A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/655B B0 EA       BCS $EA [$6547]         A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/655D 80 1B       BRA $1B [$657A]         A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/657A 48          PHA                     A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/657B AD 21 18    LDA $1821 [$00:1821]    A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/657E 0A          ASL                     A A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/657F 0A          ASL                     A A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/6580 0A          ASL                     A A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/6581 0A          ASL                     A A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/6582 0A          ASL                     A A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/6583 0A          ASL                     A A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/6584 03 01       ORA $01,s [$00:01DF]    A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/6586 83 01       STA $01,s [$00:01DF]    A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/6588 68          PLA                     A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/6589 9F 00 CC 7E STA $7ECC00,x[$7E:CC49] A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/658D A9 00       LDA #$00                A:0080 X:0049 Y:0001 P:eNVMxdIzc
$C0/658F 8F 0F CF 7E STA $7ECF0F[$7E:CF0F]   A:0000 X:0049 Y:0001 P:enVMxdIZc
$C0/6593 60          RTS                     A:0000 X:0049 Y:0001 P:enVMxdIZc

Buying Not Allowed (4 Items)

$C0/6531 BF 00 CC 7E LDA $7ECC00,x[$7E:CC49] A:0011 X:0049 Y:0001 P:eNvMxdIzc
$C0/6535 C9 FF       CMP #$FF                A:0080 X:0049 Y:0001 P:eNvMxdIzc
$C0/6537 F0 12       BEQ $12 [$654B]         A:0080 X:0049 Y:0001 P:eNvMxdIzc
$C0/6539 29 1F       AND #$1F                A:0080 X:0049 Y:0001 P:eNvMxdIzc
$C0/653B CD 20 18    CMP $1820 [$00:1820]    A:0000 X:0049 Y:0001 P:envMxdIZc
$C0/653E F0 12       BEQ $12 [$6552]         A:0000 X:0049 Y:0001 P:envMxdIZC
$C0/6552 BF 00 CC 7E LDA $7ECC00,x[$7E:CC49] A:0000 X:0049 Y:0001 P:envMxdIZC
$C0/6556 18          CLC                     A:0080 X:0049 Y:0001 P:eNvMxdIzC
$C0/6557 69 20       ADC #$20                A:0080 X:0049 Y:0001 P:eNvMxdIzc
$C0/6559 C9 9F       CMP #$9F                A:00A0 X:0049 Y:0001 P:eNvMxdIzc
$C0/655B B0 EA       BCS $EA [$6547]         A:00A0 X:0049 Y:0001 P:envMxdIzC
$C0/6547 A9 02       LDA #$02                A:00A0 X:0049 Y:0001 P:envMxdIzC
$C0/6549 80 44       BRA $44 [$658F]         A:0002 X:0049 Y:0001 P:envMxdIzC
$C0/658F 8F 0F CF 7E STA $7ECF0F[$7E:CF0F]   A:0002 X:0049 Y:0001 P:envMxdIzC
$C0/6593 60          RTS                     A:0002 X:0049 Y:0001 P:envMxdIzC

Selling

$C0/7DB1 C2 30       REP #$30                A:0006 X:FB9C Y:0001 P:envmxdIzc
$C0/7DB3 A0 0B 00    LDY #$000B              A:0006 X:FB9C Y:0001 P:envmxdIzc
$C0/7DB6 AE 3E 18    LDX $183E [$00:183E]    A:0006 X:FB9C Y:000B P:envmxdIzc
$C0/7DB9 BF 00 CC 7E LDA $7ECC00,x[$7E:CC48] A:0006 X:0048 Y:000B P:envmxdIzc
$C0/7DBD E0 48 00    CPX #$0048              A:FF40 X:0048 Y:000B P:eNvmxdIzc
$C0/7DC0 90 12       BCC $12 [$7DD4]         A:FF40 X:0048 Y:000B P:envmxdIZC
$C0/7DC2 E2 20       SEP #$20                A:FF40 X:0048 Y:000B P:envmxdIZC
$C0/7DC4 38          SEC                     A:FF40 X:0048 Y:000B P:envMxdIZC
$C0/7DC5 E9 20       SBC #$20                A:FF40 X:0048 Y:000B P:envMxdIZC
$C0/7DC7 9F 00 CC 7E STA $7ECC00,x[$7E:CC48] A:FF20 X:0048 Y:000B P:envMxdIzC
$C0/7DCB 29 F0       AND #$F0                A:FF20 X:0048 Y:000B P:envMxdIzC
$C0/7DCD D0 5B       BNE $5B [$7E2A]         A:FF20 X:0048 Y:000B P:envMxdIzC
$C0/7E2A C2 20       REP #$20                A:FF20 X:0048 Y:000B P:envMxdIzC
$C0/7E2C A9 00 00    LDA #$0000              A:FF20 X:0048 Y:000B P:envmxdIzC
$C0/7E2F 60          RTS                     A:0000 X:0048 Y:000B P:envmxdIZC

Update Limit to 9 Items

The changes to alter the limit to 9.

Check if Odd:
F0 12 29 1F
F0 12 29 0F

Increase Item & Call Check for Max Limit:
69 20 C9 9F
69 10 C9 9F

Convert Quantity:
4A 4A 4A 4A 4A 60
4A 4A 4A 4A EA 60

Decrease and Save:
E9 20 9F 00 CC 7E
E9 10 9F 00 CC 7E

Add New if First:
AD 20 18 09 20
AD 20 18 09 10

Hide Odd Values:
F0 0B 29 1F 00
F0 0B 29 0F 00

Show Item:
D0 02 29 1F
D0 02 29 0F

Use Item:
83 01 98 29 1F
83 01 98 29 0F

BF 48 CC 7E 29 1F
BF 48 CC 7E 29 0F

63 01 29 E0
63 01 29 F0

10 02 A0 E0
10 02 A0 F0

9F 48 CC 7E 29 E0
9F 48 CC 7E 29 F0

Selling:
D0 05 29 1F 00 (Show)
D0 05 29 0F 00

BF 00 CC 7E 29 1F (Sell)
BF 00 CC 7E 29 0F

Secret_of_Mana_Item_Limit_Increase.7z

Map decompression originally described by Michael1 (Alchemic) and an anonymous [ID:JJuQ5DDK] Japanese BBS source.
Title, SPC and event decompression and data described by an anonymous [ID:JJuQ5DDK] Japanese BBS source.
Tileset 16x16 compression described by Mop / Moppy.
Icon compression described by MathOnNapkins.
English Script commands described by Sephiroth3.
Drop item format described in-depth by deflaktor.
Boss graphic decompression and Item storage described by flow.