Chrono Trigger MSU-1 Overhaul

// Copyright (c) 2016, DarkShock
// Copyright (c) 2019, Cthulhu
//
// Redistribution and use in source and binary forms,
// with or without modification,
// are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

arch snes.cpu

// Boolean constants
constant false(0)
constant true(1)

scope SNES {
    scope MUL {
        // SNES multiplication registers.
        constant OPERAND_A($4202)
        constant OPERAND_B($4203)
        constant RESULT_L($4216)
        constant RESULT_H($4217)
    }

    scope DIV {
        // SNES division registers.
        constant DIVIDEND_L($4204)
        constant DIVIDEND_H($4205)
        constant DIVISOR($4206)
        constant QUOTIENT_L($4214)
        constant QUOTIENT_H($4215)
        constant REMAINDER_L($4216)
        constant REMAINDER_H($4217)
    }

    scope SPC {
        // SPC communication ports.
        constant COMM0($2140)
        constant COMM1($2141)
        constant COMM2($2142)
        constant COMM3($2143)
    }

    macro mul() {
        // x * y = a

        stx.w SNES.MUL.OPERAND_A
        sty.w SNES.MUL.OPERAND_B

        rep #$20
        xba // Ignored, just here to waste 3 cycles for the multiplication.
        nop

        lda.w SNES.MUL.RESULT_L
        sep #$20
    }

    macro div() {
        // x / y = a

        rep #$10
        stx.w SNES.DIV.DIVIDEND_L
        sep #$10

        sty.w SNES.DIV.DIVISOR

        rep #$20
        xba // Ignored, just here to waste 3 cycles for the division.
        nop
        nop
        nop
        nop
        nop

        lda.w SNES.DIV.QUOTIENT_L
        sep #$20
    }
}

scope MSU {
    // MSU memory map I/O.

    scope Output {
        constant STATUS($2000)
        constant READ($2001)
        constant ID($2002)
    }

    scope Input {
        constant SEEK($2000)
        constant TRACK_LO($2004)
        constant TRACK_HI($2005)
        constant VOLUME($2006)
        constant CONTROL($2007)
    }

    scope Flags {
        scope STATUS {
            constant TRACK_MISSING($08)
            constant AUDIO_PLAYING($10)
            constant AUDIO_REPEAT($20)
            constant AUDIO_BUSY($40)
            constant DATA_BUSY($80)
        }

        scope CONTROL {
            constant AUDIO_STOP($00)
            constant AUDIO_PLAY($01)
            constant AUDIO_REPEAT($02)
        }
    }

    scope Values {
        scope VOLUME {
            constant EMPTY($00)
            constant FULL($FF)
        }
    }
}

scope Utility {
    scope Memory {
        constant BANK($7E0000)
        constant OFFSET($1E00)

        macro load(variable offset) {
            lda.l Utility.Memory.BANK | Utility.Memory.OFFSET | offset
        }

        macro store(variable offset) {
            sta.l Utility.Memory.BANK | Utility.Memory.OFFSET | offset
        }
    }

    scope Register {
        constant P($01)
        constant A($02)
        constant X($04)
        constant Y($08)
        constant D($10)
        constant B($20)
        constant ALL(P|A|X|Y|D|B)

        macro scope backup(variable flag) {
            // Registers backup.
            if Utility.Register.P & flag {
                php
            }

            variable pflag($00)

            if Utility.Register.A & flag {
                pflag = pflag | $20
            }
            if Utility.Register.X & flag || Utility.Register.Y & flag {
                pflag = pflag | $10
            }
            if pflag {
                rep #pflag
            }

            if Utility.Register.A & flag {
                pha
            }
            if Utility.Register.X & flag {
                phx
            }
            if Utility.Register.Y & flag {
                phy
            }
            if Utility.Register.D & flag {
                phd
                Utility.direct(Utility.Memory.OFFSET)
            }
            if Utility.Register.B & flag {
                phb
            }

            if pflag {
                sep #pflag
            }

            if Utility.Register.B & flag {
                Utility.absolute($80)
            }
        }

        macro scope restore(variable flag) {
            // Registers restore.
            variable pflag($00)

            if Utility.Register.A & flag {
                pflag = pflag | $20
            }
            if Utility.Register.X & flag || Utility.Register.Y & flag {
                pflag = pflag | $10
            }
            if pflag {
                rep #pflag
            }

            if Utility.Register.B & flag {
                plb
            }
            if Utility.Register.D & flag {
                pld
            }
            if Utility.Register.Y & flag {
                ply
            }
            if Utility.Register.X & flag {
                plx
            }
            if Utility.Register.A & flag {
                pla
            }
            if Utility.Register.P & flag {
                plp
            }
        }
    }

    macro direct(variable offset) {
        // Set the direct page register to offset.
        lda.w #offset
        tcd
    }

    macro absolute(variable bank) {
        // Set the data bank register to bank.
        lda.b #bank
        pha
        plb
    }

    macro ascii(variable char) {
        // Compare an ascii character.
        lda.w source+index
        cmp.b #char
        bne fallback

        index = index + 1
    }
}

scope Game {
    scope SOUND {
        // Variable addresses
        constant COMMAND($00)
        constant REQUEST($01)
        constant FADE_TIME($01)
        constant FADE_VOLUME($02)
        constant BANK_REQUEST($10)

        // Constants
        scope COMMANDS {
            // Constants
            constant PLAY($10)
            constant RESUME($11)
            constant INTERRUPT($14)
            constant FADE($81)
            constant PAUSE($F5)
        }
    }
}

scope Track {
    // Track list
    constant LIST($CDF9C8)
    constant SIZE(256)

    scope ACTIONS {
        constant NONE($FF)
        constant STOP(MSU.Flags.CONTROL.AUDIO_STOP)
        constant PLAY(MSU.Flags.CONTROL.AUDIO_PLAY)
        constant LOOP(MSU.Flags.CONTROL.AUDIO_PLAY|MSU.Flags.CONTROL.AUDIO_REPEAT)
    }

    scope TRACKS {
        constant THEME($18)
        constant THEME_ATTRACT($54)
        constant EPOCH_1999AD($50)
        constant ENDING($3F)
    }
}

scope Patch {
    scope Flags {
        constant MSU_SUPPORTED($40)
        constant MSU_UNSUPPORTED($80)
    }

    // Patch's address.
    constant ADDRESS(Track.LIST+Track.SIZE)

    // RAM variable addresses used by this patch.
    constant FLAGS($E0) // 8-bits

    scope COUNTERS {
        constant FRAME($E1) // 8-bits
        constant TIME($E2)  // 16-bits
    }

    scope TRACK {
        constant CURRENT($E4)     // 8-bits
        constant FADE($E5)        // 8-bits
        constant FADE_VOLUME($E6) // 16-bits
        constant VOLUME($E7)      // 8-bits
        constant FADE_STEP($E8)   // 16-bits
    }

    scope GAME {
        constant ATTRACT($EA) // 8-bits
    }

    macro SynchFix(variable seconds, variable value) {
        cpx.w #seconds
        bmi +
        lda.b #value
        bra .Default
        +
    }
}

// **********
// * Macros *
// **********
macro scope seek(variable address) {
    variable bank((address >> 16) & $FF)
    variable offset(address & $FFFF)

    if {defined BUGFIX_UNCENSOR} {
        if bank >= $40 && bank <= $7D {
            // ExHiROM section, no need to change origin.
            // Physical and ExHiROM addresses are the same.
            origin address

            if offset < $8000 {
                base address
            } else {
                base (address & $3FFFFF) | $800000 // Move address to FastROM address.
            }
        } else if (bank >= $00 && bank <= $3F) || (bank >= $80 && bank <= $BF) {
            // ExHiROM section
            if offset < $8000 {
                error "Invalid ExHiROM address."
            }

            origin (address & $3FFFFF) | $400000
            base address | $800000 // Move address to FastROM address.
        } else if bank >= $C0 && bank <= $FF {
            // HiROM section, no need to change base.
            origin address & $3FFFFF
            base address
        } else {
            error "Invalid ExHiROM address."
        }
    } else {
        if (bank >= $00 && bank <= $3F) || (bank >= $80 && bank <= $BF) {
            if offset < $8000 {
                error "Invalid HiROM address."
            }

            origin address & $3FFFFF
            base address | $800000 // Move address to FastROM address.
        } else if (bank >= $40 && bank <= $7D) || (bank >= $C0 && bank <= $FF) {
            origin address & $3FFFFF
            base address | $800000 // Move address to FastROM address.
        } else {
            error "Invalid HiROM address."
        }
    }
}

// ========================
// = Original code hijack =
// ========================

// Main
seek($C70004)
    jml Patch.Main

// NMI hijack
seek($00FF10)
    jml Patch.UpdateLoop

// Check which track ID the game is reading from the ROM.
seek($C307E5)
    jsl Patch.AttractHack
    nop
    nop
    nop

// Wait for song to finish command.
seek($C03CC6)
    jsl Patch.WaitTrackFinish
    nop
    nop
    nop
    nop

// Wait for song to start (found when switching characters on overworld).
seek($C2CBE0)
    jsl Patch.WaitTrackStart
    nop
    nop
    nop
    nop

// Wait for title screen fix.
// This chunk of code is copied into RAM
// by the decompression routine, that's why
// it got a db $80 in the middle.
seek($C335AF)
    nop
    db $80
    jsl Patch.WaitTrackStart
    nop
    nop

// Bike Race ending camera animation fix.
// This is a lazy destructive hijack to the compressed code.
// Original code check if the song has started:
// 7e475c lda $2143
// 7e475f and #$0f
// 7e4761 beq $4771
seek($C3257B)
    lda.b #$01
    nop

// Epoch 1999 AD and Ending timing fix.
seek($C30C28)
-
    // Equivalent to bra $0bb5
    db $80,$8B
    jsl Patch.EpochAndEndingFix
    bcs -
    rts

// Epoch 1999 AD event modification.
// This is a destructive modification.
// Remove syncronisation with music in the event.
// NOTE: Address moved for Bugfix and Uncensor Patch.
if {defined BUGFIX_UNCENSOR} {
seek($81B5EE)
} else {
seek($FA96B1)
}
    // 10 10 is Event Command Jump Forward ten bytes.
    // This is compressed data so the modification is
    // replicated 3 times.
    db $10, $10, 0, 0, 0

// Fix for in normal combat with custom music, wrong sfx.
// Tell the SPC routine to always load the data.
seek($C70A8A)
    jml Patch.BattleSampleHack

// ============
// = MSU Code =
// ============
seek(Patch.ADDRESS)
scope Patch {

scope CheckSupport: {
    // MSU-1 support routine.
    lda.b FLAGS
    bit.b #Flags.MSU_SUPPORTED
    bne .Exit
    bit.b #Flags.MSU_UNSUPPORTED
    bne .Fail

    variable source(MSU.Output.ID)
    variable index(0)
    variable fallback(.Unsupported)

    Utility.ascii('S')
    Utility.ascii('-')
    Utility.ascii('M')
    Utility.ascii('S')
    Utility.ascii('U')
    Utility.ascii('1')

    // Store the flag so we don't have to check for MSU-1 support everytime.
    lda.b FLAGS
    ora.b #Flags.MSU_SUPPORTED
    sta.b FLAGS

.Exit:
    sec
    rts

.Unsupported:
    // Store the flag so we don't have to check for MSU-1 support everytime.
    lda.b FLAGS
    ora.b #Flags.MSU_UNSUPPORTED
    sta.b FLAGS

.Fail:
    clc
    rts
}

scope Main: {
    Utility.Register.backup(Utility.Register.ALL)

    jsr CheckSupport
    bcc .Default

    lda.b Game.SOUND.COMMAND

    // Play
    cmp.b #Game.SOUND.COMMANDS.PLAY
    bne +
    jsr PlayTrack
    bra .Default
+
    // Resume
    cmp.b #Game.SOUND.COMMANDS.RESUME
    bne +
    jsr PlayTrack
    bra .Default
+
    // Interrupt
    cmp.b #Game.SOUND.COMMANDS.INTERRUPT
    bne +
    jsr PlayTrack
    bra .Default
+
    // Fade
    cmp.b #Game.SOUND.COMMANDS.FADE
    bne +
    jsr FadeTrack
    bra .Default
+
    // Pause/unpause during battle
    cmp.b #Game.SOUND.COMMANDS.PAUSE
    bne .Default
    jsr PauseTrack

.Default:
    // Original routine
    Utility.Register.restore(Utility.Register.ALL)

    jml $C70140
}

scope PlayTrack: {
    // X: Track ID | Y: Play type
    ldx.b Game.SOUND.REQUEST
    beq .Stop

    cpx.b #Track.TRACKS.THEME
    bne +
    lda.b GAME.ATTRACT
    beq +
    // Change attract theme.
    ldx.b #Track.TRACKS.THEME_ATTRACT
+
    cpx.b TRACK.CURRENT
    bne +
    // Is audio still playing?
    lda.w MSU.Output.STATUS
    bit.b #MSU.Flags.STATUS.AUDIO_PLAYING
    bne .Continue
+
    lda.l Track.LIST,x // ldy Track.LIST,x will not work here as ldy doesn't have a long instruction.
    beq .Stop
    bmi .Exit
    tay // Store our play type value on Y so we don't have to get it again.

    stz.w MSU.Input.CONTROL
    stx.w MSU.Input.TRACK_LO
    stz.w MSU.Input.TRACK_HI

.Check:
    // Wait until MSU-1 is done loading our track.
    lda.w MSU.Output.STATUS
    bit.b #MSU.Flags.STATUS.AUDIO_BUSY
    bne .Check

    // Check if track is missing.
    bit.b #MSU.Flags.STATUS.TRACK_MISSING
    bne .Stop

.Play:
    stx.b TRACK.CURRENT

    // Reset counters at the start of a music.
    stz.b COUNTERS.FRAME
    rep #$20
    stz.b COUNTERS.TIME
    sep #$20

    lda.b TRACK.FADE
    bne +

    lda.b #MSU.Values.VOLUME.FULL
    sta.b TRACK.VOLUME

    stz.b TRACK.FADE_VOLUME
+
    // Set volume.
    lda.b TRACK.VOLUME
    sta.w MSU.Input.VOLUME

    // Play/Resume the track.
    sty.w MSU.Input.CONTROL

.Continue:
    // Tell the SPC to not play any track.
    stz.b Game.SOUND.REQUEST

.Exit:
    rts

.Stop:
    // Stop the current track.
    stz.w MSU.Input.CONTROL
    stz.w MSU.Input.VOLUME

    stz.b TRACK.CURRENT
    stz.b TRACK.VOLUME
    stz.b TRACK.FADE
    stz.b TRACK.FADE_VOLUME

    cpx.b #Track.TRACKS.THEME_ATTRACT
    beq +
    stz.b GAME.ATTRACT
+
    rep #$20
    stz.b TRACK.FADE_STEP

    rts
}

scope FadeTrack: {
    lda.b Game.SOUND.FADE_VOLUME
    cmp.b TRACK.VOLUME
    beq .Exit

    stz.b TRACK.FADE_VOLUME

    ldy.b Game.SOUND.FADE_TIME
    beq .Set
    sty.b TRACK.FADE

    sec
    sbc.b TRACK.VOLUME
    bcs +
    eor.b #MSU.Values.VOLUME.FULL
    inc
+
    tax
    SNES.div()

    bcs +
    eor.b #MSU.Values.VOLUME.FULL
+
    sta.b TRACK.FADE_STEP+1

    lda.w SNES.DIV.REMAINDER_L
    xba
    rep #$10
    tax
    SNES.div()

    bcs +
    eor.b #MSU.Values.VOLUME.FULL
+
    sta.b TRACK.FADE_STEP

    bcs .Exit

    rep #$20
    inc.b TRACK.FADE_STEP

.Exit:
    rts

.Set:
    stz.b TRACK.FADE

    cmp.b #MSU.Values.VOLUME.EMPTY
    bne +
    // Stop track if the volume is 0.
    stz.w MSU.Input.CONTROL
+
    sta.b TRACK.VOLUME
    sta.w MSU.Input.VOLUME

    rep #$20
    stz.b TRACK.FADE_STEP

    rts
}

scope PauseTrack: {
    // Do we have a track playing to pause/unpause?
    ldx.b TRACK.CURRENT
    beq .Exit

    lda.b Game.SOUND.REQUEST
    cmp.b #Game.SOUND.COMMANDS.PAUSE
    beq .Pause

    lda.l Track.LIST,x
    sta.w MSU.Input.CONTROL

.Exit:
    rts

.Pause:
    stz.w MSU.Input.CONTROL

    rts
}

scope UpdateLoop: {
    Utility.Register.backup(Utility.Register.P|Utility.Register.A|Utility.Register.D)

    lda.b TRACK.CURRENT
    cmp.b #Track.TRACKS.EPOCH_1999AD
    beq +
    cmp.b #Track.TRACKS.ENDING
    beq +

    lda.b TRACK.FADE
    beq .Default
+
    lda.l MSU.Output.STATUS
    bit.b #MSU.Flags.STATUS.AUDIO_PLAYING
    beq .Default

    lda.b COUNTERS.FRAME
    inc
    cmp.b #60
    bpl .Reset

    sta.b COUNTERS.FRAME

.Fade:
    lsr // Increase/Reduce volume every odd frame.
    bcc .Default

    lda.b TRACK.FADE
    beq .Default
    dec
    sta.b TRACK.FADE

    clc
    rep #$20
    lda.b TRACK.FADE_VOLUME
    adc.b TRACK.FADE_STEP
    sta.b TRACK.FADE_VOLUME
    sep #$20

    xba
    sta.l MSU.Input.VOLUME
    bne .Default
    // Stop track if the volume is 0.
    lda.b #MSU.Flags.CONTROL.AUDIO_STOP
    sta.l MSU.Input.CONTROL
    stz.b TRACK.FADE
    stz.b TRACK.FADE_VOLUME

.Default:
    Utility.Register.restore(Utility.Register.P|Utility.Register.A|Utility.Register.D)

    jml $000500

.Reset:
    stz.b COUNTERS.FRAME

    // Increment counter at each second (each 60 fps).
    // Will be used to fake timing for Epoch 1999 scene and ending.
    rep #$20
    inc.b COUNTERS.TIME

    bra .Default
}

scope AttractHack: {
    Utility.Register.backup(Utility.Register.P)

    rep #$10

    cpx.w #$6E01
    bne .Default

    sep #$20
    phb
    pla

    cmp.b #$DB
    bne .Default

    // $DB6E01
    lda.b #true
    Utility.Memory.store(GAME.ATTRACT)

.Default:
    Utility.Register.restore(Utility.Register.P)

    // Original code
    lda.w $0001,x
    sta.l $002180

    rtl
}

scope WaitTrackStart: {
    Utility.Memory.load(TRACK.CURRENT)
    beq .Default

.MSU:
    lda.l MSU.Output.STATUS
    and.b #MSU.Flags.STATUS.AUDIO_PLAYING
    beq .MSU

    rtl

.Default:
    // Original code
    lda.l SNES.SPC.COMM3
    and.b #$0F
    beq .Default

    rtl
}

scope WaitTrackFinish: {
    Utility.Memory.load(TRACK.CURRENT)
    beq .Default

.MSU:
    lda.w MSU.Output.STATUS
    and.b #MSU.Flags.STATUS.AUDIO_PLAYING
    bne +
    inx
+
    rtl

.Default:
    // Original code
    lda.w SNES.SPC.COMM3
    and.b #$0F
    bne +
    inx
+
    rtl
}

scope EpochAndEndingFix: {
    rep #$20
    phd
    Utility.direct(Utility.Memory.OFFSET)
    sep #$20

    php
    rep #$10
    phx
-
    lda.b TRACK.CURRENT
    // Original evaluation
    bne +
    lda.l SNES.SPC.COMM2
    cmp.l SNES.SPC.COMM2
    bne -

    jmp .Default
+
    ldx.b COUNTERS.TIME

    cmp.b #Track.TRACKS.EPOCH_1999AD
    beq .Epoch
    cmp.b #Track.TRACKS.ENDING
    beq .Ending

    plx
    plp
    pld

    sec
    rtl

.Epoch:
    SynchFix(49, 5)
    SynchFix(21, 3)
    SynchFix(16, 2)
    SynchFix(7, 1)
    lda.b #0

    bra .Default

.Ending:
    SynchFix(280, 10)
    SynchFix(253, 9)
    SynchFix(193, 8)
    SynchFix(159, 7)
    SynchFix(127, 6)
    SynchFix(104, 5)
    SynchFix(77, 4)
    SynchFix(45, 3)
    SynchFix(24, 2)
    SynchFix(17, 1)
    lda.b #0

.Default:
    plx
    plp
    pld

    // Original code
    and.b #$0F
    cmp ($20)
    bpl +

    rep #$20
    dec.b $20

    clc
    rtl
+
    sec
    rtl
}

scope BattleSampleHack: {
    Utility.Memory.load(Game.SOUND.BANK_REQUEST)
    beq .NotInCombat

    jml $C70A96

.NotInCombat:
    // Original code
    dec
-
    cmp.w SNES.SPC.COMM0
    beq -
    pla
    pla
    pla

    jml $C70192
}

}

// Track list for MSU-1.
// NONE: Ignored.
// STOP: Stop playing current track.
// PLAY: Play track, but only once.
// LOOP: Play track on loop.
seek(Track.LIST)
    db Track.ACTIONS.STOP // ($00)
    db Track.ACTIONS.LOOP // ($01) 1.05 - Green Memories
    db Track.ACTIONS.LOOP // ($02) 1.09 - Yearnings of the Wind
    db Track.ACTIONS.LOOP // ($03) 3.04 - Corridor of Time
    db Track.ACTIONS.LOOP // ($04) 2.20 - Rhythm of Earth, Wind, and Sky
    db Track.ACTIONS.LOOP // ($05) 2.01 - A Desolate World
    db Track.ACTIONS.LOOP // ($06) 1.06 - Guardia's Millennial Fair
    db Track.ACTIONS.LOOP // ($07) 3.09 - Crono & Marle - A Distant Promise
    db Track.ACTIONS.LOOP // ($08) 1.11 - Secret Of The Forest
    db Track.ACTIONS.LOOP // ($09) 3.05 - Zeal Palace
    db Track.ACTIONS.LOOP // ($0A) 2.10 - Derelict Factory
    db Track.ACTIONS.LOOP // ($0B) 2.19 - Ayla's Theme
    db Track.ACTIONS.LOOP // ($0C) 1.13 - Guardia Castle - Pride & Glory
    db Track.ACTIONS.LOOP // ($0D) 2.05 - Lavos' Theme
    db Track.ACTIONS.LOOP // ($0E) 2.09 - Robo's Theme
    db Track.ACTIONS.PLAY // ($0F) 1.03 - Morning Glow
    db Track.ACTIONS.LOOP // ($10) 1.15 - The Cathedral
    db Track.ACTIONS.STOP // ($11)
    db Track.ACTIONS.STOP // ($12)
    db Track.ACTIONS.LOOP // ($13) 3.10 - The Epoch - Wings of Time
    db Track.ACTIONS.LOOP // ($14) 3.06 - Schala's Theme
    db Track.ACTIONS.LOOP // ($15) 2.14 - Jolly Ol' Spekkio
    db Track.ACTIONS.LOOP // ($16) 1.23 - Critical Moment
    db Track.ACTIONS.LOOP // ($17) 1.21 - The Trial
    db Track.ACTIONS.LOOP // ($18) 1.02 - The Chrono Trigger Symphony
    db Track.ACTIONS.STOP // ($19)
    db Track.ACTIONS.STOP // ($1A)
    db Track.ACTIONS.LOOP // ($1B) 1.20 - Fanfare 1
    db Track.ACTIONS.PLAY // ($1C) 2.12 - Fanfare 2
    db Track.ACTIONS.LOOP // ($1D) 3.03 - Depths of the Night
    db Track.ACTIONS.LOOP // ($1E) 1.04 - Peaceful Days
    db Track.ACTIONS.LOOP // ($1F) 1.08 - Strange Occurences
    db Track.ACTIONS.STOP // ($20)
    db Track.ACTIONS.STOP // ($21)
    db Track.ACTIONS.STOP // ($22)
    db Track.ACTIONS.LOOP // ($23) 1.22 - The Hidden Truth
    db Track.ACTIONS.PLAY // ($24) 1.16 - A Prayer for the Wayfarer
    db Track.ACTIONS.PLAY // ($25) 1.14 - Huh
    db Track.ACTIONS.LOOP // ($26) 2.06 - The Last Day of the World
    db Track.ACTIONS.LOOP // ($27) 2.07 - Johnny of the Robo Gang
    db Track.ACTIONS.LOOP // ($28) 2.24 - Magus Confronted
    db Track.ACTIONS.LOOP // ($29) 1.18 - Boss Battle 1
    db Track.ACTIONS.LOOP // ($2A) 1.19 - Frog's Theme
    db Track.ACTIONS.PLAY // ($2B) 1.10 - Good Night
    db Track.ACTIONS.LOOP // ($2C) 2.08 - Bike Chase
    db Track.ACTIONS.LOOP // ($2D) 2.04 - Those Without the Will to Live
    db Track.ACTIONS.PLAY // ($2E) 2.02 - Mystery from the Past
    db Track.ACTIONS.LOOP // ($2F) 2.16 - Creeping through the Sewers
    db Track.ACTIONS.PLAY // ($30) 1.01 - A Premonition
    db Track.ACTIONS.LOOP // ($31) 3.08 - Ocean Palace
    db Track.ACTIONS.LOOP // ($32) 3.14 - The Final Battle
    db Track.ACTIONS.LOOP // ($33) 2.03 - Site 16
    db Track.ACTIONS.STOP // ($34)
    db Track.ACTIONS.STOP // ($35)
    db Track.ACTIONS.LOOP // ($36) 2.21 - Burn! Bobonga! Burn!
    db Track.ACTIONS.STOP // ($37)
    db Track.ACTIONS.LOOP // ($38) 2.18 - Primeval Mountain
    db Track.ACTIONS.LOOP // ($39) 3.13 - World Revolution
    db Track.ACTIONS.STOP // ($3A)
    db Track.ACTIONS.LOOP // ($3B) 3.07 - Sealed Door
    db Track.ACTIONS.LOOP // ($3C) 1.17 - Light of Silence
    db Track.ACTIONS.PLAY // ($3D) 2.15 - Fanfare 3
    db Track.ACTIONS.LOOP // ($3E) 2.13 - At the End of Time
    db Track.ACTIONS.PLAY // ($3F) 3.17 - Outskirts of Time
    db Track.ACTIONS.LOOP // ($40) 2.23 - Strains of Insanity
    db Track.ACTIONS.STOP // ($41)
    db Track.ACTIONS.LOOP // ($42) 1.07 - Gato's Song
    db Track.ACTIONS.STOP // ($43)
    db Track.ACTIONS.LOOP // ($44) 3.11 - Black Omen
    db Track.ACTIONS.LOOP // ($45) 1.12 - Battle
    db Track.ACTIONS.LOOP // ($46) 3.02 - Tyrano Lair
    db Track.ACTIONS.STOP // ($47)
    db Track.ACTIONS.PLAY // ($48) 2.22 - The Fiendlord's Keep
    db Track.ACTIONS.LOOP // ($49) 3.15 - Festival of Stars
    db Track.ACTIONS.STOP // ($4A)
    db Track.ACTIONS.STOP // ($4B)
    db Track.ACTIONS.STOP // ($4C)
    db Track.ACTIONS.LOOP // ($4D) 3.16 - Epilogue - To My Dear Friends
    db Track.ACTIONS.LOOP // ($4E) 2.17 - Boss Battle 2
    db Track.ACTIONS.STOP // ($4F)
    db Track.ACTIONS.LOOP // ($50) 3.12 - Determination
    db Track.ACTIONS.LOOP // ($51) 2.11 - Battle 2
    db Track.ACTIONS.LOOP // ($52) 3.01 - Singing Mountain
    db Track.ACTIONS.STOP // ($53)
    db Track.ACTIONS.PLAY // ($54) 1.02 - The Chrono Trigger Symphony
    db Track.ACTIONS.LOOP // ($55) 2.05 - Lavos' Theme
    db Track.ACTIONS.STOP // ($56)
    db Track.ACTIONS.STOP // ($57)
    db Track.ACTIONS.STOP // ($58)
    db Track.ACTIONS.STOP // ($59)
    db Track.ACTIONS.STOP // ($5A)
    db Track.ACTIONS.STOP // ($5B)
    db Track.ACTIONS.STOP // ($5C)
    db Track.ACTIONS.STOP // ($5D)
    db Track.ACTIONS.STOP // ($5E)
    db Track.ACTIONS.STOP // ($5F)
    db Track.ACTIONS.STOP // ($60)
    db Track.ACTIONS.STOP // ($61)
    db Track.ACTIONS.STOP // ($62)
    db Track.ACTIONS.STOP // ($63)
    db Track.ACTIONS.STOP // ($64)
    db Track.ACTIONS.STOP // ($65)
    db Track.ACTIONS.STOP // ($66)
    db Track.ACTIONS.STOP // ($67)
    db Track.ACTIONS.STOP // ($68)
    db Track.ACTIONS.STOP // ($69)
    db Track.ACTIONS.STOP // ($6A)
    db Track.ACTIONS.STOP // ($6B)
    db Track.ACTIONS.STOP // ($6C)
    db Track.ACTIONS.STOP // ($6D)
    db Track.ACTIONS.STOP // ($6E)
    db Track.ACTIONS.STOP // ($6F)
    db Track.ACTIONS.STOP // ($70)
    db Track.ACTIONS.STOP // ($71)
    db Track.ACTIONS.STOP // ($72)
    db Track.ACTIONS.STOP // ($73)
    db Track.ACTIONS.STOP // ($74)
    db Track.ACTIONS.STOP // ($75)
    db Track.ACTIONS.STOP // ($76)
    db Track.ACTIONS.STOP // ($77)
    db Track.ACTIONS.STOP // ($78)
    db Track.ACTIONS.STOP // ($79)
    db Track.ACTIONS.STOP // ($7A)
    db Track.ACTIONS.STOP // ($7B)
    db Track.ACTIONS.STOP // ($7C)
    db Track.ACTIONS.STOP // ($7D)
    db Track.ACTIONS.STOP // ($7E)
    db Track.ACTIONS.STOP // ($7F)
    db Track.ACTIONS.STOP // ($80)
    db Track.ACTIONS.STOP // ($81)
    db Track.ACTIONS.STOP // ($82)
    db Track.ACTIONS.STOP // ($83)
    db Track.ACTIONS.STOP // ($84)
    db Track.ACTIONS.STOP // ($85)
    db Track.ACTIONS.STOP // ($86)
    db Track.ACTIONS.STOP // ($87)
    db Track.ACTIONS.STOP // ($88)
    db Track.ACTIONS.STOP // ($89)
    db Track.ACTIONS.STOP // ($8A)
    db Track.ACTIONS.STOP // ($8B)
    db Track.ACTIONS.STOP // ($8C)
    db Track.ACTIONS.STOP // ($8D)
    db Track.ACTIONS.STOP // ($8E)
    db Track.ACTIONS.STOP // ($8F)
    db Track.ACTIONS.STOP // ($90)
    db Track.ACTIONS.STOP // ($91)
    db Track.ACTIONS.STOP // ($92)
    db Track.ACTIONS.STOP // ($93)
    db Track.ACTIONS.STOP // ($94)
    db Track.ACTIONS.STOP // ($95)
    db Track.ACTIONS.STOP // ($96)
    db Track.ACTIONS.STOP // ($97)
    db Track.ACTIONS.STOP // ($98)
    db Track.ACTIONS.STOP // ($99)
    db Track.ACTIONS.STOP // ($9A)
    db Track.ACTIONS.STOP // ($9B)
    db Track.ACTIONS.STOP // ($9C)
    db Track.ACTIONS.STOP // ($9D)
    db Track.ACTIONS.STOP // ($9E)
    db Track.ACTIONS.STOP // ($9F)
    db Track.ACTIONS.STOP // ($A0)
    db Track.ACTIONS.STOP // ($A1)
    db Track.ACTIONS.STOP // ($A2)
    db Track.ACTIONS.STOP // ($A3)
    db Track.ACTIONS.STOP // ($A4)
    db Track.ACTIONS.STOP // ($A5)
    db Track.ACTIONS.STOP // ($A6)
    db Track.ACTIONS.STOP // ($A7)
    db Track.ACTIONS.STOP // ($A8)
    db Track.ACTIONS.STOP // ($A9)
    db Track.ACTIONS.STOP // ($AA)
    db Track.ACTIONS.STOP // ($AB)
    db Track.ACTIONS.STOP // ($AC)
    db Track.ACTIONS.STOP // ($AD)
    db Track.ACTIONS.STOP // ($AE)
    db Track.ACTIONS.STOP // ($AF)
    db Track.ACTIONS.STOP // ($B0)
    db Track.ACTIONS.STOP // ($B1)
    db Track.ACTIONS.STOP // ($B2)
    db Track.ACTIONS.STOP // ($B3)
    db Track.ACTIONS.STOP // ($B4)
    db Track.ACTIONS.STOP // ($B5)
    db Track.ACTIONS.STOP // ($B6)
    db Track.ACTIONS.STOP // ($B7)
    db Track.ACTIONS.STOP // ($B8)
    db Track.ACTIONS.STOP // ($B9)
    db Track.ACTIONS.STOP // ($BA)
    db Track.ACTIONS.STOP // ($BB)
    db Track.ACTIONS.STOP // ($BC)
    db Track.ACTIONS.STOP // ($BD)
    db Track.ACTIONS.STOP // ($BE)
    db Track.ACTIONS.STOP // ($BF)
    db Track.ACTIONS.STOP // ($C0)
    db Track.ACTIONS.STOP // ($C1)
    db Track.ACTIONS.STOP // ($C2)
    db Track.ACTIONS.STOP // ($C3)
    db Track.ACTIONS.STOP // ($C4)
    db Track.ACTIONS.STOP // ($C5)
    db Track.ACTIONS.STOP // ($C6)
    db Track.ACTIONS.STOP // ($C7)
    db Track.ACTIONS.STOP // ($C8)
    db Track.ACTIONS.STOP // ($C9)
    db Track.ACTIONS.STOP // ($CA)
    db Track.ACTIONS.STOP // ($CB)
    db Track.ACTIONS.STOP // ($CC)
    db Track.ACTIONS.STOP // ($CD)
    db Track.ACTIONS.STOP // ($CE)
    db Track.ACTIONS.STOP // ($CF)
    db Track.ACTIONS.STOP // ($D0)
    db Track.ACTIONS.STOP // ($D1)
    db Track.ACTIONS.STOP // ($D2)
    db Track.ACTIONS.STOP // ($D3)
    db Track.ACTIONS.STOP // ($D4)
    db Track.ACTIONS.STOP // ($D5)
    db Track.ACTIONS.STOP // ($D6)
    db Track.ACTIONS.STOP // ($D7)
    db Track.ACTIONS.STOP // ($D8)
    db Track.ACTIONS.STOP // ($D9)
    db Track.ACTIONS.STOP // ($DA)
    db Track.ACTIONS.STOP // ($DB)
    db Track.ACTIONS.STOP // ($DC)
    db Track.ACTIONS.STOP // ($DD)
    db Track.ACTIONS.STOP // ($DE)
    db Track.ACTIONS.STOP // ($DF)
    db Track.ACTIONS.STOP // ($E0)
    db Track.ACTIONS.STOP // ($E1)
    db Track.ACTIONS.STOP // ($E2)
    db Track.ACTIONS.STOP // ($E3)
    db Track.ACTIONS.STOP // ($E4)
    db Track.ACTIONS.STOP // ($E5)
    db Track.ACTIONS.STOP // ($E6)
    db Track.ACTIONS.STOP // ($E7)
    db Track.ACTIONS.STOP // ($E8)
    db Track.ACTIONS.STOP // ($E9)
    db Track.ACTIONS.STOP // ($EA)
    db Track.ACTIONS.STOP // ($EB)
    db Track.ACTIONS.STOP // ($EC)
    db Track.ACTIONS.STOP // ($ED)
    db Track.ACTIONS.STOP // ($EE)
    db Track.ACTIONS.STOP // ($EF)
    db Track.ACTIONS.STOP // ($F0)
    db Track.ACTIONS.STOP // ($F1)
    db Track.ACTIONS.STOP // ($F2)
    db Track.ACTIONS.STOP // ($F3)
    db Track.ACTIONS.STOP // ($F4)
    db Track.ACTIONS.STOP // ($F5)
    db Track.ACTIONS.STOP // ($F6)
    db Track.ACTIONS.STOP // ($F7)
    db Track.ACTIONS.STOP // ($F8)
    db Track.ACTIONS.STOP // ($F9)
    db Track.ACTIONS.STOP // ($FA)
    db Track.ACTIONS.STOP // ($FB)
    db Track.ACTIONS.STOP // ($FC)
    db Track.ACTIONS.STOP // ($FD)
    db Track.ACTIONS.STOP // ($FE)
    db Track.ACTIONS.NONE // ($FF)