Final Fantasy IV battle graphics and sound (everything8215's disassembly)

On a town or dungeon map, a battle starts with sound effect $3F and 42 frames of mosaic before the field hands over to the battle program. The routine first leaves only BG1 and BG2 on the main screen, hiding the sprites, and then writes a 21-byte table to the mosaic register, each byte for 2 frames: the block size, on BG1 and BG2, rises and falls twice through 1, 3, 5, 7, 5 and 3 pixels square, then rises through 1, 3, 5 and 7 and on through 9, 11, 13 and 15 to 16. The same routine starts a battle that an event command or a scripted scene calls. Before it hands over, it reads the battle background from the map again, except for a battle a treasure chest starts. ff4-av/field-battle-mosaic

About: Final Fantasy IV Battle transition

Value: frames 42 · sfx 63 · frames per byte 2 · blocks 1, 3, 5, 7, 5, 3, 1, 3, 5, 7, 5, 3, 1, 3, 5, 7, 9, 11, 13, 15, 16

The mosaic register's high nibble is the size n, drawing blocks n + 1 pixels square, and its low nibble picks the layers, here $3 for BG1 and BG2. The loop counter runs 0 to 41 and the table index is the counter halved, so each of the 21 bytes stays 2 frames. The loop never writes the brightness.

On the world map, a battle starts with the same sound effect, $3F, and 40 frames of Mode 7 zoom. The routine shows only BG1 on the main screen, hiding the sprites, and each frame turns HDMA off, takes the next of 40 zoom bytes and rebuilds the Mode 7 matrix from it at the map's current rotation. The world map's loader sets the zoom byte to $10; the battle's table rises from $10 to $16 and back twice, then falls to 0 over the last 16 frames. Each matrix entry is a sine value times the zoom byte over 256, so at $16 the entries are 1.375 times their size at $10 and at 0 they are 0 (computed): the map pulls back twice, then grows until one point of it fills the screen. The brightness stays as it is. ff4-av/world-battle-zoom

About: Final Fantasy IV Mode 7

{
 "frames": 40,
 "sfx": 63,
 "zoom": [
  16,
  17,
  18,
  19,
  20,
  21,
  22,
  21,
  20,
  19,
  18,
  17,
  16,
  17,
  18,
  19,
  20,
  21,
  22,
  21,
  20,
  19,
  18,
  17,
  16,
  15,
  14,
  13,
  12,
  11,
  10,
  8,
  7,
  6,
  5,
  4,
  3,
  2,
  1,
  0
 ],
 "baseZoom": 16
}

The multiply unit's product read from its middle byte up is the product over 256. A Mode 7 matrix entry is the step through the map for one screen pixel, so a larger matrix shows more of the map in the same screen and a matrix near 0 magnifies one texel across it; that is the hardware's rule, not this routine's. The loop never writes the brightness register, so the screen goes from the zoom to the battle at whatever brightness the map had. $212C is the main screen designation; $01 is BG1.

A battle's background is picked on the field before the battle starts. On the world map, bits 0 to 2 of the tile under the party index a six-entry table of backgrounds ($00, $0A, $01, $09, $0F, $05); indexes 6 and 7 would read past the table, and this claim doesn't follow whether any tile gives them. On a town or dungeon map it is the map's own battle background, with bit 6 set for a cave with water when the tile's water bit is set, bit 5 set when the map asks for the alternate background palette, and the magnetized-cave flag cleared unless event switch $E1 is set. Battles $1B7 and $1B8 always get background $10, the final battle's. ff4-av/battle-background

Value: world table 0, 10, 1, 9, 15, 5 · final battle bg 16 · final battles 439, 440

The table has six entries, but the index has three bits; tiles whose bits give 6 or 7 would read the two bytes after the table, which are code, and this claim doesn't follow which tiles have them. On a town or dungeon map the background number is the low four bits of the map's property byte. The background byte's top bit is the magnetized-cave flag the RAM map names (the Cave of Magnes), which the battle program reads.

A battle's song comes from bits 2 and 3 of the seventh byte of its battle properties: values 0, 1 and 2 pick songs $27, $1A and $0B from a three-entry table (Battle 1, Battle 2 and The Dreadful Fight in the disassembly's battle editor), and 3 keeps the song that was playing. The battle program sends the song once the battle's data is loaded, before the battle graphics start, and repeats the request until the sound driver reports that song playing. ff4-av/battle-music

Value: songs 39, 26, 11 · keep 3

The battle start copies the battle's eight property bytes to $299C up, so $29A2 is byte 6 counted from 0, the seventh. The song names are the disassembly's rip definition, which labels the values in its battle editor; the code names none of them.

The battle screen opens from black over 16 frames, its brightness rising by one step a frame from 0 to full (15), while the battle background on BG2 comes out of a mosaic: blocks 16 pixels square at first, shrinking by one pixel every 2 frames to none after 32 frames. Meanwhile the monsters slide into place over 22 frames: their layer's scroll, set per line through HDMA, falls from 252 pixels to 0 along a sine curve (252, 240, 228, … 24, 12, 0; computed), horizontally for an ordinary battle and negated in a back attack, or vertically for flying monsters; the directions (from the left, from the right in a back attack, from above) and which flag means flying are the source's comments, not followed. Player input waits until the menu is open and both effects are done. ff4-av/battle-opening

About: Final Fantasy IV HDMA

Value: brightness frames 16 · mosaic frames 32 · entry frames 22 · entry offsets 252, 240, 228, 216, 204, 196, 184, 172, 160, 148, 136, 124, 112, 100, 88, 76, 64, 48, 36, 24, 12, 0

The mosaic byte's low nibble $2 is BG2, and its size is the frame counter halved, so 15, 15, 14, 14 … 0, 0 (computed); a size n draws blocks n + 1 pixels square. The source's comment says the monster entry takes 24 frames, but the counter starts at $16, 22. The entry offset is the sine byte times 4 in an 8-bit register, written as the low byte of each line's BG1 scroll. A back attack negates it (two's complement), so its offsets are 256 minus these. Which way the monsters move on screen comes from the source's comments; this claim doesn't trace the two halves of BG1's map the scroll's high byte picks between.

Every battle ends, won, lost or fled, with 15 frames (computed) in which the screen dims by one step a frame, from 15 to 1, while a mosaic on BG1, BG2 and on alternate frames BG4 grows from none to blocks 8 pixels square, one pixel every 2 frames (sizes 0 to 7, computed). Before it the battle program fades the music, a slow fade after a win or an escape and a plain one after a defeat, unless the battle kept the map's song, gave items, or was battle $1B7. ff4-av/battle-exit

About: Final Fantasy IV Screen fade

Value: frames 15 · slow fade 133 · fade 139 · max block 8

The counter shifted left 3 puts its bit 0 in the mosaic register's BG4 bit and its upper bits in the size, so the size is the counter halved, 0 to 7 (computed), and odd counts also set BG4. Battles $1C0 and up count as giving items too. Battle $1B7 is Zeromus in the source's comment.

A damage number is four 8-pixel digit sprites and a blank fifth, right-aligned: the value's low 14 bits are turned into five decimal digits, the ten-thousands digit is dropped, and up to three leading zeros are hidden, so the ones digit always shows. The digits start 16 pixels left of the target's position and 8 above it; in a back attack that x position becomes 223 minus it (its bits inverted, less 32; computed), which mirrors the number across the screen. Damage is drawn with the sprite attributes $31, sprite palette 0, which the source's comment calls white, and a value with bit 15 set, which the code's comment marks as not HP damage, with $3D, palette 6, green; a miss replaces the digits with the miss tiles (four in the English release). A target whose value is 0, flags included, shows nothing. One pass draws the numbers for all 13 combatants at once, 8 monsters and 5 characters, and the battle waits until it ends. ff4-av/damage-numerals

Value: digits 4 · sprites 5 · digit width 8 · value bits 14 · damage attr 49 · heal attr 61 · damage palette 0 · heal palette 6 · slots 13 · x offset -16 · y offset -8

The flag in $f0fa is 0 to draw, 1 to skip, $FF for a miss, the reverse of what the source's comments on it say: the routine sets it to 1 when the whole value word is 0. Each combatant gets five buffer bytes, the first left blank, and the draw loop reads five from the second, so the fifth sprite is the next combatant's blank byte. Sprite attribute bits 1 to 3 are the palette, so $31 is palette 0 and $3D palette 6. Values from 10,000 to 16,383 would lose their first digit on screen; this claim doesn't follow whether the battle program ever stores one.

A damage or healing number lives 41 frames (computed), and its digits bounce one after another, left to right: each digit follows a 65-byte table of heights, the leftmost 12 frames ahead of the blank fifth sprite and each digit to its right 3 frames behind the one before. A digit rests for its first 4 table steps, rises to 16 pixels by step 12, holds there to step 14, comes back down on step 22, bounces once to 5 pixels at steps 26 to 28, and lands on step 33. A miss's tiles all bounce together, on the rightmost digit's timing. ff4-av/damage-number-bounce

{
 "frames": 41,
 "digitDelay": 3,
 "heights": [
  0,
  0,
  0,
  0,
  0,
  3,
  6,
  9,
  12,
  14,
  15,
  15,
  16,
  16,
  16,
  15,
  15,
  14,
  12,
  9,
  6,
  3,
  0,
  2,
  4,
  4,
  5,
  5,
  5,
  4,
  4,
  2,
  1,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0,
  0
 ],
 "peak": 16,
 "bounce": 5
}

The counter is incremented before it is read, and on the frame it reaches $2A (42) the numbers are switched off and not drawn, so they show for counts 1 to 41. Sprite k from the left takes the table at the count plus 3 × (4 − k), so the leftmost digit's height runs 12 steps ahead (computed). Every digit has finished its bounce by count 30 (the ones digit, at 3 steps ahead, reaches step 33 then), and the numbers then sit still to the end.

When ordinary monsters die, the dying monsters' tiles switch to background palette 7, which is loaded with a 16-color death palette (after a transparent color and a dark blue, six shades of violet from red 22, green 16, blue 31 down to 4, 0, 13), and the death sound plays: $10 for an ordinary kill. For 48 frames every color of that palette loses one step of red, green and blue (of 31), stopping at black, so the figures are black from the 31st frame, and each frame an HDMA table picks, line by line, which of two copies of the monster layer shows: one drawn with the dying monsters, one without. Within each 32-line band the lines still showing the dying monsters fall from 14 of every 16 to 2 (computed), in a pattern that shifts each frame and mirrors about the band's middle; at the end every line shows the copy without them. ff4-av/monster-death

About: Final Fantasy IV HDMA

{
 "frames": 48,
 "sfx": 16,
 "palette": 7,
 "colors": [
  [
   0,
   0,
   0
  ],
  [
   0,
   0,
   11
  ],
  [
   22,
   16,
   31
  ],
  [
   22,
   10,
   31
  ],
  [
   22,
   0,
   31
  ],
  [
   16,
   0,
   25
  ],
  [
   10,
   0,
   19
  ],
  [
   4,
   0,
   13
  ],
  [
   0,
   0,
   0
  ],
  [
   0,
   0,
   17
  ],
  [
   31,
   31,
   31
  ],
  [
   26,
   26,
   31
  ],
  [
   20,
   20,
   31
  ],
  [
   14,
   14,
   31
  ],
  [
   8,
   8,
   31
  ],
  [
   0,
   0,
   23
  ]
 ],
 "linesShown": [
  14,
  14,
  14,
  14,
  14,
  13,
  13,
  13,
  14,
  14,
  13,
  13,
  13,
  13,
  12,
  12,
  13,
  12,
  12,
  11,
  11,
  11,
  10,
  10,
  9,
  8,
  8,
  7,
  7,
  6,
  6,
  5,
  4,
  4,
  4,
  4,
  3,
  3,
  3,
  2,
  2,
  2,
  2,
  3,
  2,
  2,
  2,
  2
 ]
}

Each per-line value is the high byte of BG1's horizontal scroll, which picks one of the two 256-pixel halves of BG1's 512-pixel map. Before the animation the routine draws the monsters with the dying ones recolored into one half and shows it everywhere (value 1), then draws the survivors into the other half; it ends with every line at 0, and the battle shows 0 after the monster entry too, so 1 is the copy with the dying monsters. Line k of each band takes table entry (frame + k) for k = 0 to 15, and lines 16 to 31 mirror lines 15 to 0. The death sound is indexed by the death type the battle program sets: 0 for an ordinary kill, 2 for the Life effect and a monster's revival, 1 from the call for help, 4 for a monster running away, 5 for Explode and the reaction effect; type 3, a change of form, skips the animation. Only types 0 and 5 play $10. The two halves of the death palette are animation palettes 5 and 6; the dying monsters' tiles show the colors their pixels select.

In the 9 battles flagged for it (of 512; computed), a monster killed in the ordinary way dies by a boss's effect instead: sound effect $5E plays, and after 16 frames the monster layer is erased line by line from the top, one more line every 4 frames, 128 lines over 512 frames (computed), while it shakes sideways each frame by 1, 2, 4, 2, 1, 0, 2 and 2 pixels in turn. Below the erased lines runs a 32-line band in which 11 lines are erased too, every other line next to the edge and fewer farther down, so the edge is dithered. Then it requests sound effect 0, which plays nothing; since every sound request first keys off the two sound-effect channels, this ends the boss's sound. The palette is left alone. ff4-av/boss-death

Value: battles 9 · of 512 · sfx 94 · wait frames 16 · lines 128 · frames per line 4 · frames 512 · band 32 · band erased 0, 2, 4, 6, 8, 10, 12, 15, 18, 22, 27 · shake 1, 2, 4, 2, 1, 0, 2, 2

Each of the 140 lines' BG1 scroll gets $0100, the half the routine has cleared, if it lies at or above the edge; the shake offset with the mask's $0100 added (exclusive or) in the 32-line band below; and the shake offset alone farther down. The edge line is the counter, which starts at 0 and stops after 127, so its last frame leaves lines 0 to 127 erased and the band's first 12 lines below it. The flag is bit 4 of the battle's first property byte, which the disassembly's rip definition names Boss Death Animation; a kill by another death type takes the ordinary death in these battles too.

A spell's animation runs from a 4-byte entry in a table of 192 attack animations: its palette, its graphics, an animation script and one of 48 hand-written animation routines; $FF in either the script byte or the routine byte skips the whole animation. The routine runs the script in its own way: routine 0 runs it on the targets, then again for a reflected spell. A script opens with two bytes. The first gives one of 16 frame sizes, from 1 by 1 to 16 columns by 9 rows of 16-pixel tiles, and how many times the script repeats, 1 to 16. The second gives the speed, a step every 8, 4, 2 or 1 frames, a bit that turns off mirroring, and in bits 0 to 2 which block of 128 animation frames the script's frame numbers count from. Then comes a byte stream with five kinds of byte: $00 to $7F shows that frame and ends the step, $FF ends the script, $88 and a parameter byte starts or stops a palette effect, other bytes with bit 3 set start a flashing palette on the targets, and the rest move the animation 1 to 8 pixels in one of 8 directions. Commands take no time. ff4-av/anim-script-format

Value: entries 192 · routines 48 · scripts 79 · frame sizes 16 · repeats 1, 16 · frames per step 8, 4, 2, 1 · move distances 1, 8 · directions 8

A frame byte advances the script only on frames where the frame counter masked by the speed byte ($07, $03, $01 or $00) is 0, so each frame shows for that many frames plus one. The frame sizes are the table's pairs of columns and rows; the drawer steps 16 pixels per tile and centers the frame by half of each. The block byte times 128 plus the frame number indexes the frame pointer table, which has 361 entries. The parameter of $88 is a palette swap when its bit 3 is set and a color flash otherwise (ff4-av/color-flash). Mirroring is on unless the header's bit 7 is set; it flips the frames and swaps forward and back. The bit-3 bytes have a stop branch, which the disassembly's comment calls $8C, but the test before it can't send a byte there; the one such byte in the ROM's scripts, $8F, starts a flash.

The 79 animation scripts hold 865 frame bytes and 407 moves, and the commands spread unevenly: 53 scripts flash a palette on their targets, 37 start a palette swap, 33 move the animation, and 15 start a color flash. 49 run at a step every 2 frames, 16 every 4, 9 every frame and 5 every 8, and 43 play once while the rest repeat, up to 9 times. 55 turn mirroring off (all computed). ff4-av/anim-scripts-use

{
 "scripts": 79,
 "frameBytes": 865,
 "moves": 407,
 "targetFlash": 53,
 "paletteSwap": 37,
 "moving": 33,
 "colorFlash": 15,
 "speeds": {
  "1": 9,
  "2": 49,
  "4": 16,
  "8": 5
 },
 "once": 43,
 "maxRepeat": 9,
 "mirrorOff": 55
}

The palette-swap and color-flash counts split $88's parameter by its bit 3, as the interpreter does; a parameter of $08, which stops the swap, isn't counted. A script can use several kinds.

Spells flash the screen with color math: a fixed color, any mix of red, green and blue, is added to BG1 and BG2, the monsters and the battle background, by the color math HDMA table, which covers the top 140 lines (computed) and turns color math off below them, over the menu. Five kinds of flash exist: on 2 frames and off 2 until stopped, a pulse rising from 0 to full (31) and back a step a frame until stopped, a single frame, a rise to a set level that holds, and a fall to 0 that ends it. Scripts start one with command $88; routines call it by color. The routine the source names Black Hole darkens the background and flashes white for 32 frames; Big Bang flashes green, red, yellow, blue and white for 8 frames each, four times over. ff4-av/color-flash

About: Final Fantasy IV Color math

Value: kinds 5 · lines 140 · full 31 · black hole frames 32 · big bang frames 8 · big bang rounds 4 · big bang colors green, red, yellow, blue, white

The flash types are the routine's: 1 tests bit 1 of a counter that rises each frame, so 2 frames on and 2 off; 2 climbs to 31 and back and turns round at 0 again; 3 stops after one frame; 4 climbs to a target value; 5 falls and then turns the flash off. The screen-flash entry points start type 1 at full strength, and a routine stops it by clearing the type. The color math value $03 adds to BG1 and BG2; a routine can set another in its place. The HDMA table writes the color math control once for 100 lines and again for 40, then 0, so 140 lines (computed). Type 6 behaves like type 2.

In the 2 battles flagged for transparent monsters (of 512; computed), the monsters show at half strength over the battle background: color math puts BG2 on the sub screen and adds it to BG1, the monsters' layer, halving the sum. Odin's summon sets the same color math partway through its attack loop, from the 17th of its 64 frames (computed). ff4-av/transparent-monsters

About: Final Fantasy IV Color math

Value: battles 2 · of 512 · cgadsub 65 · sub screen 2

$41 in the color math control is half-add (bit 6) on BG1 (bit 0); $02 in the sub screen designation is BG2, and the same $02 in the window control selects the sub screen as the color source. While a flash runs, its own setting replaces this one. Odin's counter starts at 0 and rises one a frame, the transparency is set once it reaches 16, the 17th frame, and the loop ends when it reaches 64 (both computed). Odin's loop first points BG1 at another tile map, so what turns transparent there is Odin's layer; this claim doesn't follow what it holds.

Battles run in BG mode 1, with no Mode 7: the monsters are on BG1 and the battle background on BG2. Four HDMA channels run through a battle, three setting BG1, BG2 and BG3's horizontal and vertical scroll line by line, and one setting the color math control; these per-line tables carry the shakes, the monster deaths, the final battle's moving background and the flashes. ff4-av/battle-layers

About: Final Fantasy IV HDMA

Value: bg mode 1 · hdma channels 4

$87 enables channels 0, 1, 2 and 7. Mode $43 writes two registers twice a line through a pointer table, a scroll register's low and high bytes for horizontal and vertical. The field's world map zoom into a battle is Mode 7 (ff4-av/world-battle-zoom); the battle itself isn't.

Quake shakes the screen by repeating an 8-frame pattern of offsets, 1, 2, 4, 2, 1, 0, 2 and 2 pixels, written to the battle background's scroll table line by line and to the monsters' or to some characters' positions. The final battle's background is never shaken this way. ff4-av/battle-shake

About: Final Fantasy IV Screen shake

Value: pattern 1, 2, 4, 2, 1, 0, 2, 2 · frames 8

The pattern is indexed by the script's frame counter masked to 0 to 7. Which side shakes comes from bit 7 of an attack byte: clear, the background shakes with the characters marked in a 5-bit mask; set, with the monster layer. That this bit marks the side the attack hits is a reading, not followed here. The background table is BG2's horizontal scroll, by the comment on the final background's update, so the shake is sideways. Values other than 1 in the shake switch pick other shake routines, not followed.

The final battle's background scrolls sideways in 18 strips, 17 of 8 lines and one of 4 (140 lines, computed), each moving its own number of pixels a frame: 5, 4, 3, 2 and 1 in the top five strips, none in the sixth, then 1 to 12 down to the bottom, all the same way. Big Bang first slows the rates by one a frame until every strip runs backward three times as fast (−15 to −36), flashes, and then brings them back the same way; the bottom strip, the last to arrive, takes 48 frames each way (computed). ff4-av/final-battle-background

About: Final Fantasy IV HDMA

Value: strips 18 · lines 140 · forward 5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 · back -15, -12, -9, -6, -3, 0, -3, -6, -9, -12, -15, -18, -21, -24, -27, -30, -33, -36 · ramp frames 48

Each strip's rate is added to its lines' horizontal scroll every frame, from the vblank routine. Rates in the forward table are all zero or positive, so every strip moves the same way at a speed that grows with its distance from the sixth strip (lines 40 to 47, computed). Each ramp step waits a frame and moves every strip still short of its target by one; the bottom strip goes from 12 to −36, 48 steps. Big Bang's shake value 7 is set before the ramp.

When a battle is won, song 8, the fanfare, is requested, unless the battle kept the field's music instead of playing its own. Seven battles, listed by number, get the fanfare even then. Next, every character who is alive and not stone takes the victory pose, except in nine listed battles. ff4-av/victory-fanfare

Value: song 8 · fanfare list 220, 221, 225, 231, 423, 431, 438 · no pose list 235, 245, 240, 250, 425, 254, 243, 436, 439

The first list's label calls it the battles with no fanfare, but a match jumps straight to the request, so these battles play it where the music field alone would skip it; the label reads the list the wrong way round. The test for the field's music is the song field's value 3 (bits 2 and 3 both set). Pose 8 is the one the victory animation gives; the pose itself is a sprite frame not followed here.

After a win the gil and experience are added, each capped at 9,999,999, and the experience is shared out among the party members who are alive and not stone, at least 1 each when there is any. One window then shows "Received {n} GP." and "Received {n} Exp.", the experience being each member's share, either line left out when it is zero. Then, character by character, while one has enough experience for the next level and is below level 99, it gains the level, and the window shows "{name} gained a level." followed by one "Learned {spell}" for each spell that level teaches, so a character who gains two levels gets the pair twice. ff4-av/victory-messages

Value: cap 9999999 · max level 99 · party slots 5

The divisor counts the first five slots whose character exists and is neither dead nor stone, and that the battle marks ($3540 is checked only for those five); the code also pays the five slots after them, which this claim doesn't follow. A slot past the fifth gains levels without a message. The braces stand for the message's variable codes, which the window fills with the amounts, the name and the spell. Message $24 reads "Perished……".

Battle sounds are requested by number, with a stereo position: an attack's animation looks its sound up in a 256-entry table, and the battle code gives it pan $C0 or $40 by bit 7 of the attack, which side each means not followed, or the center, $80, for sounds $31 and $33, reversing the pan in a back attack. The sound program finds the number in a table of 128 entries, each two script pointers, and plays one script on each of the last two of its 8 channels, cutting off whatever they held; 99 of the 128 use both channels, 27 one, and 2, numbers 0 and 79, none (all computed). Menu sounds such as the cursor and the error buzz are a separate set of 16 numbers with their own table. ff4-av/sound-effects

About: Final Fantasy IV Sound effects

{
 "attackTable": 256,
 "sounds": 128,
 "twoChannels": 99,
 "oneChannel": 27,
 "silent": [
  0,
  79
 ],
 "channels": [
  6,
  7
 ],
 "pan": {
  "center": 128,
  "monsters": 192,
  "characters": 64
 },
 "systemSounds": 16
}

A channel is skipped when its pointer equals the next one or its high byte is 0, so an entry whose two pointers match plays on one channel. The table holds sound numbers 0 to 127; the attack table's largest is 114 (computed). Which side each pan value means is the source's comment, not checked against the sound program's pan direction. The battle requests system sounds through the same vblank routine; the CPU side passes $10 to $1E, while the sound program's table has 16 entries, 7 of them filled. The sound scripts themselves aren't followed here, and no source found names the 128 sounds.

Final Fantasy IV and VI both have two ways into a battle: a mosaic on town and dungeon maps, a Mode 7 zoom on the world map, each after one battle sound. VI feeds the mosaic through an HDMA table where IV writes the register directly, and its zoom also dims the screen nearly to black, where IV's leaves the brightness alone. The battle screen then opens differently: IV brightens the whole screen and clears a mosaic from the background while the monsters slide in; VI opens a band from the middle of the battlefield with color math. ff4-av/changes-ff6-transition

Both games build a damage number from digit tiles out of the value's low 14 bits, with no ten-thousands place, white for damage and green for healing, and drive its motion by a table of heights. IV right-aligns four digits and bounces them one after another from left to right; VI centers the number and moves it as a whole. ff4-av/changes-ff6-numbers

Both games kill an ordinary monster the same way at heart: its picture switches to a death palette whose colors lose one step of red, green and blue a frame until black, with the death sound. IV's monsters are background tiles, so it removes them line by line with an HDMA table that switches between two copies of the monster layer; VI's are sprites, and it adds them to the background with color math and then drops them from the shown set. IV's death palette is violet, VI's magenta. In IV's flagged boss battles the boss is wiped from the top down over a shake, where VI runs a death script of its own that the boss's AI asks for. ff4-av/changes-ff6-death

Both games' animation scripts open with two header bytes, run a byte stream in which a byte below $80 shows a frame and ends the step and $FF ends the script, and run their commands at once. IV's commands are a handful of kinds, palette effects and moves, and a hand-written routine for the spell can run the script with steps of its own; VI turns the bytes from $80 up into a command set with a second page behind $80 and runs a script per layer, many threads side by side. ff4-av/changes-ff6-script

Both games request a victory fanfare after a win unless the battle kept the map's music, and both share the experience among the living. IV forces the fanfare for a short list of battles, VI turns it off by a battle flag. IV shows a level-up message for every level gained, each followed by its spells; VI shows one however many levels come, and adds more lines (espers' magic points, Lores, items dropped). ff4-av/changes-ff6-victory

Both sound programs keep a table that gives each sound effect two channel scripts, and both battles queue a sound with a pan and send it once a frame. IV pans by a bit of the attack, three positions in all; VI pans by the animation's target position across the screen. ff4-av/changes-ff6-sound

About: Final Fantasy IV Sound effects

Battle $1B7, one of the two the final battle's background is set for, ends with a death of its own. It requests song $42 and plays one of four sounds at each flash, picked by the low two bits of a value this claim doesn't follow. The screen flashes white, yellow and red a frame each, waits 64 frames, flashes yellow and waits 32 more, flashes the three colors again, and then the monster layer shakes by the 8-frame shake pattern while it sinks one pixel every 16 frames, 160 pixels in all, with three more three-color flashes in every 256 frames, 30 in all; the sinking takes about 2,618 frames, some 43.6 seconds (all computed). A last sound plays when it has sunk. ff4-av/final-boss-death

Value: battle 439 · song 66 · sounds 14, 27, 46, 87 · sink 160 · frames per pixel 16 · end sound 32

The vertical scroll falls from 0 to −160 ($FF60), and a lower scroll value moves the layer down, so the monster sinks. The loop's one-byte counter is stored from the accumulator, which holds 3 from the three-color flash run before it, so the first step comes on the 14th pass and the 160th on pass 2,558 (14 + 159 × 16). The flashes in the loop come at counter values $10, $20 and $8C, ten times each as the counter wraps, and each flash adds the two frames it waits, 60 in all; 2,558 + 60 = 2,618 frames (all computed). A flag at $38E6 skips the sequence; it isn't followed.