Swan's Quest, Chapter 4: The sequence completes

2:26 - Barebones example of a sequencer

// A barebones example of a sequencer

let numberOfBeats = 8   // two bars of 4/4
let duration = 4.0      // seconds

let interval = duration / Double(numberOfBeats)

var index = 0
Timer.scheduledTimer(withTimeInterval: interval, repeats: true) { timer in
    // Play each track's Instrument
    // ...
    
    index = (index + 1 < numberOfBeats) ? index + 1 : 0
}

3:16 - Introduction to playInstrument(_:note:volume:)

// Sequencer.swift

func playInstrument(_ kind: Instrument.Kind, note: MIDINoteProtocol, volume: Double = 75)


// Instrument.swift

public class Instrument {

    /// The kind of included instruments
    public enum Kind: String {
        case electricGuitar, bassGuitar, piano, warmBells, sevenSynth, 
            bassSynth, crystalSynth
    }
    
    // ...
}

3:38 - MIDINoteProtocol

// Sequencer.swift 

protocol MIDINoteProtocol {
    
    /// note as an 8-bit MIDI code
    var midiCode: UInt8 { get }
}

3:48 - Example implementation for Notes

// Example implementation for Notes

enum MIDINotes: UInt8, MIDINoteProtocol {
    case rest = 0
    
    case C2 = 36
    case D2 = 38
    case E2 = 40
    case F2 = 41
    case G2 = 43
    case A2 = 45
    case B2 = 47
        
    var midiCode: UInt8 {
        return self.rawValue
    }
}

4:03 - TrackProtocol

// Sequencer.swift

protocol TrackProtocol {
    associatedtype NoteType : MidiNoteProtocol
    
    /// The kind of instrument that the track sequences
    var instrument: Instrument.Kind { get }
    
    /// Number of beats contained in the sequence
    var length: Int { get }
    
    /// MIDI code for the sequence frame
    func note(for frame: Int) -> NoteType
}

4:21 - Example implementation for Tracks

// Example implementation for Tracks

struct Track : TrackProtocol {
    var instrument: Instrument.Kind
    var length: Int
    
    var notes: [MIDINotes]? = nil
    
    func note(for frame: Int) -> MIDINotes {
        guard let n = notes, frame < n.count else {
            return .rest
        }
        return n[frame]
    }
}

4:34 - Implementing a Sequencer

// A barebones example of a sequencer

let numberOfBeats = 8   // two bars of 4/4
let duration = 4.0      // seconds

var bass = Track(instrument: .bassGuitar, length: numberOfBeats)
var piano = Track(instrument: .piano, length: numberOfBeats)
let tracks = [bass, piano]

bass.notes =  [.rest, .C2, .A2, .rest, .C2, .A2, .D2, .C2 ]
piano.notes = [.A2, .A2, .C2, .F2, .A2, .C2, .none, .F2]

let interval = duration / Double(numberOfBeats)
var index = 0
Timer.scheduledTimer(withTimeInterval: interval, repeats: true, block: { timer in
    for track in tracks {
        playInstrument(track.instrument, note: track.note(for: index))
    }
    index = (index + 1 < numberOfBeats) ? index + 1 : 0
})

5:00 - // Getting credit for our work

// Getting credit for our work

Timer.scheduledTimer(withTimeInterval: interval, repeats: true, block: { timer in
    for track in tracks {
        playInstrument(track.instrument, note: track.note(for: index))
    }
    
    if index + 1 < numberOfBeats {
        index = index + 1
    }
    
    else {
        index = 0
        owner.endPerformance()
    }
})