quasi-random-durations

#!/usr/bin/env perl
use strict;
use warnings;

use v5.20.0;

use Data::Dumper::Compact 'ddc';
use lib map { "$ENV{HOME}/sandbox/$_/lib" } qw(MIDI-Drummer-Tiny MIDI-Util Music-Duration-Partition);
use MIDI::Drummer::Tiny;
use MIDI::Util qw(set_chan_patch);
use Music::Duration::Partition;
use Music::Scales qw(get_scale_MIDI);
use Music::VoiceGen;

my $beats  = shift || 4;
my $bars   = shift || 16;
my $bpm    = shift || 105;
my $note   = shift || 'A';
my $bscale = shift || 'pminor';
my $tscale = shift || 'minor';
my $bpatch = shift || 35;
my $tpatch = shift || 4;

# Start off in the bass register
my $octave = 1;

# Someone find the drummer!
my $d = MIDI::Drummer::Tiny->new(
    file      => "$0.mid",
    bpm       => $bpm,
    signature => $beats . '/4',
    bars      => $bars,
);

# Play the parts simultaneously
$d->score->synch(
    \&drums,
    \&bottom,
    \&top,
);

# Write the scrore to a MIDI file
$d->write;

sub bottom {
    set_chan_patch($d->score, 0, $bpatch);

    # Create a rhythmic phrase generator
    my $mdp = Music::Duration::Partition->new(
        size => $beats,
        pool => [qw(hn dqn qn)],
#        weights => [1, 1, 2],
    );

    # Create 2 phrases
    my @phrases = map { { motif => $mdp->motif } } 1 .. 2;

    # Create 2 bass octaves
    my @pitches = (
        get_scale_MIDI($note, $octave, $bscale),
        get_scale_MIDI($note, $octave + 1, $bscale),
    );

    # Create a pitch generator
    my $voice = Music::VoiceGen->new(
        pitches   => \@pitches,
        intervals => [qw(-4 -3 -2 -1 1 2 3 4)],
    );

    # Start the pitch generation at the bottom of the register
    $voice->context($pitches[0]);

    # Create two voice mappings for each phrase
    for my $phrase (@phrases) {
        push $phrase->{voices}->@*, [ map { $voice->rand } $phrase->{motif}->@* ];
        push $phrase->{voices}->@*, [ map { $voice->rand } $phrase->{motif}->@* ];
    }

    # Add the bass notes to the score
    for my $i (1 .. $d->bars) {
        # Select a random phrase
        my $phrase = $phrases[int rand @phrases];
        # Select a random voice mapping
        my $voices = ($phrase->{voices}->@*)[int rand $phrase->{voices}->@*];
        # Add the voiced motif to the score
        for my $n (0 .. $phrase->{motif}->$#*) {
            $d->note($phrase->{motif}[$n], $voices->[$n]);
        }
    }

    # Add a final resolving whole note to the score
    $d->note($d->whole, $pitches[0]);
}

sub top {
    set_chan_patch($d->score, 1, $tpatch);

    my $mdp = Music::Duration::Partition->new(
        size => $beats,
        pool => [qw(hn qn en)],
        weights => [1, 2, 3],
    );

    my @phrases = map { { motif => $mdp->motif } } 1 .. 4;

    my @pitches = (
        get_scale_MIDI($note, $octave + 2, $bscale),
        get_scale_MIDI($note, $octave + 3, $bscale),
    );
    my $voice = Music::VoiceGen->new(
        pitches   => \@pitches,
        intervals => [qw(-4 -3 -2 -1 1 2 3 4)],
    );

    for my $phrase (@phrases) {
        push $phrase->{voices}->@*, [ map { $voice->rand } $phrase->{motif}->@* ];
        push $phrase->{voices}->@*, [ map { $voice->rand } $phrase->{motif}->@* ];
    }

    for my $i (1 .. $d->bars) {
        my $phrase = $phrases[int rand @phrases];
        my $voices = ($phrase->{voices}->@*)[int rand $phrase->{voices}->@*];
        for my $n (0 .. $phrase->{motif}->$#*) {
            # Get a fluctuating velocity between f and fff
            my $vol = 'v' . (96 + int(rand 32));
            $d->note($phrase->{motif}[$n], $voices->[$n], $vol);
        }
    }

    $d->note($d->whole, $pitches[0]);
}

sub drums {
    if ($beats == 3) {
        $d->metronome34;
    }
    elsif ($beats == 4) {
        $d->metronome44;
    }
    elsif ($beats == 5) {
        $d->metronome54;
    }
    elsif ($beats == 7) {
        $d->metronome74;
    }
    else {
        warn "Unknown beat number\n";
        $d->count_in;
    }

    $d->note($d->whole, $d->crash1, $d->kick);
}