inevitable_cacophony 0.0.0

data/lib/inevitable_cacophony/octave_structure.rb

@@ -0,0 +1,233 @@
+# Represents and parses Dwarf Fortress scale descriptions
+
+require 'inevitable_cacophony/parser/sectioned_text'
+
+module InevitableCacophony
+        class OctaveStructure
+        
+                # Frequency scaling for a difference of one whole octave
+                OCTAVE_RATIO = 2
+        
+                # Represent a sequence of notes from an octave -- either a chord,
+                # or the notes of a scale.
+                # TODO: call this something more useful
+                class NoteSequence
+        
+                        # @param note_scalings [Array<Float>] The frequencies of each note in the scale,
+                        #                                     as multiples of the tonic.
+                        def initialize(note_scalings)
+                                @note_scalings = note_scalings
+                        end
+        
+                        attr_accessor :note_scalings
+        
+                        def length
+                                note_scalings.length
+                        end
+                end
+        
+                class Chord < NoteSequence
+                end
+        
+                # As above, but also tracks the chords that make up the scale.
+                class Scale < NoteSequence
+        
+                        # @param chords [Array<Chord>] The chords that make up the scale, in order.
+                        # @param note_scalings [Array<Fixnum>] Specific note scalings to use; for internal use.
+                        def initialize(chords, note_scalings=nil)
+                                @chords = chords
+                                super(note_scalings || chords.map(&:note_scalings).flatten)
+                        end
+        
+                        # Convert this scale to an "open" one -- i.e. one not including
+                        # the last note of the octave.
+                        #
+                        # This form is more convenient when concatenating scales together.
+                        #
+                        # @return [Scale]
+                        def open
+                                if note_scalings.last == OCTAVE_RATIO
+        
+                                        # -1 is the last note; we want to end on the one before that, so -2
+                                        Scale.new(@chords, note_scalings[0..-2])
+                                else
+                                        # This scale is already open.
+                                        self
+                                end
+                        end
+                end
+        
+                # Regular expressions used in parsing
+                OCTAVE_STRUCTURE_SENTENCE = /Scales are constructed/
+        
+                # @param scale_text [String] Dwarf Fortress musical form description including scale information.
+                # TODO: Allow contructing these without parsing text
+                def initialize(scale_text)
+                        description = Parser::SectionedText.new(scale_text)
+                        octave_description = description.find_paragraph(OCTAVE_STRUCTURE_SENTENCE)
+                        @octave_divisions = parse_octave_structure(octave_description)
+        
+                        @chords = parse_chords(description)
+                        @scales = parse_scales(description, chords)
+                end
+        
+                attr_reader :chords, :scales
+        
+                # @return [Scale] A scale including all available notes in the octave.
+                #                   (As the chromatic scale does for well-tempered Western instruments)
+                def chromatic_scale
+                        Scale.new([], @octave_divisions + [2])
+                end
+        
+                private
+        
+                def parse_octave_structure(octave_paragraph)
+                        octave_sentence = octave_paragraph.find(OCTAVE_STRUCTURE_SENTENCE)
+                        note_count_match = octave_sentence.match(/Scales are constructed from ([-a-z ]+) notes spaced evenly throughout the octave/)
+        
+                        if note_count_match
+                                note_count_word = note_count_match.captures.first
+                                divisions = parse_number_word(note_count_word)
+                                numerator = divisions.to_f
+        
+                                (0...divisions).map { |index| 2 ** (index/numerator) }
+                        else
+                                parse_exact_notes(octave_paragraph)
+                        end
+                end
+        
+                def parse_exact_notes(octave_paragraph)
+                        exact_spacing_sentence = octave_paragraph.find(/their spacing is roughly/)
+                        spacing_match = exact_spacing_sentence.match(/In quartertones, their spacing is roughly 1((-|x){23})0/)
+        
+                        if spacing_match
+                                # Always include the tonic
+                                note_scalings = [1]
+        
+                                note_positions = spacing_match.captures.first
+                                step_size = 2**(1.0 / note_positions.length.succ)
+                                ratio = 1
+                                note_positions.each_char do |pos|
+                                        ratio *= step_size
+                                        
+                                        case pos
+                                        when 'x'
+                                                note_scalings << ratio
+                                        when '-'
+                                                # Do nothing; no note here
+                                        else
+                                                raise "Unexpected note position symbol #{pos.inspect}"
+                                        end
+                                end
+        
+                                note_scalings
+                        else
+                                raise "Cannot parse octave text"
+                        end
+                end
+        
+                # @param description [Parser::SectionedText] The description text from which to extract chord data.
+                def parse_chords(description)
+        
+                        # TODO: extract to constant
+                        chord_paragraph_regex = /The ([^ ]+) [a-z]*chord is/
+        
+                        {}.tap do |chords|
+                                chord_paragraphs = description.find_all_paragraphs(chord_paragraph_regex)
+        
+                                chord_paragraphs.each do |paragraph|
+                                        degrees_sentence = paragraph.find(chord_paragraph_regex)
+        
+                                        name, degrees = degrees_sentence.match(/The ([^ ]+) [a-z]*chord is the (.*) degrees of the .* scale/).captures
+                                        chords[name.to_sym] = parse_chord(degrees)
+                                end
+                        end
+                end
+        
+                # @param degrees[String] The list of degrees used by this particular scale
+                def parse_chord(degrees)
+                        ordinals = degrees.split(/(?:,| and) the/)
+        
+                        chord_notes = ordinals.map do |degree_ordinal|
+                                # degree_ordinal is like "4th",
+                                # or may be like "13th (completing the octave)"
+                                # in which case it's not in our list of notes, but always has a factor of 2
+                                # (the tonic, an octave higher)
+        
+                                if degree_ordinal.include?('(completing the octave)')
+                                        2
+                                else
+                                        index = degree_ordinal.strip.to_i
+                                        @octave_divisions[index - 1]
+                                end
+                        end
+        
+                        Chord.new(chord_notes)
+                end
+        
+                # @param description [Parser::SectionedText]
+                # @param chords [Hash{Symbol,Chord}]
+                def parse_scales(description, chords)
+                        scale_topic_regex = /The [^ ]+ [^ ]+ scale is/
+        
+                        {}.tap do |scales|
+                                description.find_all_paragraphs(scale_topic_regex).each do |scale_paragraph|
+                                        scale_sentence = scale_paragraph.find(scale_topic_regex)
+                                        name, scale_type = scale_sentence.match(/The ([^ ]+) [a-z]+tonic scale is (thought of as .*|constructed by)/).captures
+        
+                                        case scale_type
+                                        when /thought of as ([a-z]+ )?(disjoint|joined) chords/
+                                                scales[name.to_sym] = parse_disjoint_chords_scale(scale_paragraph, chords)
+                                        else
+                                                raise "Unknown scale type #{scale_type} in #{scale_sentence}"
+                                        end
+                                end
+                        end
+                end
+        
+                def parse_disjoint_chords_scale(scale_paragraph, chords)
+                        chords_sentence = scale_paragraph.find(/These chords are/)
+                        chord_list = chords_sentence.match(/These chords are named ([^.]+)\.?/).captures.first
+                        chord_names = chord_list.split(/,|and/).map(&:strip).map(&:to_sym)
+        
+                        Scale.new(chords.values_at(*chord_names))
+                end
+        
+                # Convert a number word to text -- rough approximation for now.
+                # TODO: Rails or something may do this.
+                #
+                # @param word [String]
+                # @return [Fixnum]
+                def parse_number_word(word)
+                        words_to_numbers = {
+                                'one' => 1,
+                                'two' => 2,
+                                'three' => 3,
+                                'four' => 4,
+                                'five' => 5,
+                                'six' => 6,
+                                'seven' => 7,
+                                'eight' => 8,
+                                'nine' => 9,
+                                'ten' => 10,
+                                'eleven' => 11,
+                                'twelve' => 12,
+                                'thirteen' => 13,
+                                'fourteen' => 14,
+                                'fifteen' => 15,
+                                'sixteen' => 16,
+                                'seventeen' => 17,
+                                'eighteen' => 18,
+                                'nineteen' => 19,
+                        }
+        
+                        if words_to_numbers[word]
+                                words_to_numbers[word]
+                        elsif word.start_with?('twenty-')
+                                words_to_numbers[word.delete_prefix('twenty-')] + 20
+                        else
+                                "Unsupported number name #{word}"
+                        end
+                end
+        end
+end

data/lib/inevitable_cacophony/parser/rhythm_line.rb

@@ -0,0 +1,79 @@
+# Parses Dwarf Fortress rhythm lines, like | x x'X - |,
+# into Inevitable Cacophony's own internal rhythm representation.
+
+require 'inevitable_cacophony/rhythm'
+
+module InevitableCacophony
+        module Parser
+        	class RhythmLine
+        
+        		# Amplitude symbols used by Dwarf Fortress
+        		# These are in no particular scale; the maximum volume will be whatever's loudest in any particular string.
+        		BEAT_VALUES = {
+        
+        		        # Silence
+        		        '-' => 0,
+        
+        		        # Regular beat
+        		        'x' => 4,
+        
+        		        # Accented beat
+        		        'X' => 6,
+        
+        		        # Primary accent
+        		        '!' => 9
+        		}
+        
+        		# Values for each kind of timing symbol.
+        		# By default a beat is in the middle of its time-slice (0.0);
+        		# a value of 1.0 means to play it as late as possible,
+        		# and -1.0 means play as early as possible.
+        		#
+        		# Technically position of these matters, but we handle that in the parser regexp.
+        		TIMING_VALUES = {
+        
+        		        # Normal beat (no special timing)
+        		        '' => 0.0,
+        
+        		        # Early beat
+        		        '`' => -1.0,
+        
+        		        # Late beat
+        		        '\'' => 1.0
+        		}
+        
+        		BAR_LINE = '|'
+        
+        		# @param rhythm_string [String] In the notation Dwarf Fortress produces, like | X x ! x |
+        		# @return [Rhythm]
+        		def parse(rhythm_string)
+        
+        		        # TODO: should I be ignoring bar lines? Is there anything I can do with them?
+        		        raw_beats = rhythm_string.split(/ |(?=`)|(?<=')/).reject { |beat| beat == BAR_LINE }.map do |beat|
+        		                timing_symbol = beat.chars.reject { |char| BEAT_VALUES.keys.include?(char) }.join
+        		                timing = TIMING_VALUES[timing_symbol] || raise("Unknown timing symbol #{timing_symbol}")
+        
+        		                accent_symbol = beat.delete(timing_symbol)
+        		                amplitude = BEAT_VALUES[accent_symbol] || raise("Unknown beat symbol #{accent_symbol}")
+        
+        		                Rhythm::Beat.new(amplitude, 1, timing)
+        		        end
+        
+        		        # Ensure all our amplitudes are between 0.0 and 1.0
+        		        # TODO: find a way to do this without creating twice as many beats as we need.
+        		        highest_volume = raw_beats.map(&:amplitude).max
+        		        scaled_beats = raw_beats.map do |beat|
+        		                scaled = beat.amplitude.to_f / highest_volume
+        
+        		                Rhythm::Beat.new(scaled, 1, beat.timing)
+        		        end
+        
+        			Rhythm.new(scaled_beats)
+        		end
+        
+        		def self.parse(rhythm_string)
+        			new.parse(rhythm_string)
+        		end
+        	end
+        end
+end

data/lib/inevitable_cacophony/parser/rhythms.rb

@@ -0,0 +1,138 @@
+# Knows how to parse the rhythm-description paragraphs
+# of a Dwarf Fortress musical form
+
+require 'inevitable_cacophony/parser/sectioned_text'
+require 'inevitable_cacophony/parser/rhythm_line'
+require 'inevitable_cacophony/polyrhythm'
+
+module InevitableCacophony
+        module Parser
+        
+        	# TODO: maybe move errors elsewhere
+        	class Error < StandardError
+        	end
+        
+        	class UnknownBaseRhythm < Error
+        		def initialize(base)
+        			@base = base
+        
+        			super("Could not find base rhythm #{base} for polyrhythm")
+        		end
+        
+        		attr_accessor :base
+        	end
+        
+        	class UnrecognisedFormSyntax < Error
+        	end
+        
+        	# For all the Americans out there, following Webster rather than Johnson :-)
+        	UnrecognizedFormSyntax = UnrecognisedFormSyntax
+        
+        	class Rhythms
+        
+        		# Regular expressions used in parsing
+        		SIMPLE_RHYTHM_SENTENCE = /The (?<name>[[:alpha:]]+) rhythm is a single line with [-a-z ]+ beats?( divided into [-a-z ]+ bars in a [-0-9]+ pattern)?(\.|$)/
+        		COMPOSITE_RHYTHM_SENTENCE = /The (?<name>[[:alpha:]]+) rhythm is made from [-a-z ]+ patterns: (?<patterns>[^.]+)(\.|$)/
+        
+        		# "the <rhythm>". Used to match individual components in COMPOSITE_RHYTHM_SENTENCE
+        		THE_RHYTHM = /the (?<rhythm_name>[[:alpha:]]+)( \((?<reference_comment>[^)]+)\))?/
+        		IS_PRIMARY_COMMENT = 'considered the primary'
+        
+        		# Used to recognise how multiple rhythms are to be combined
+        		COMBINATION_TYPE_SENTENCE = /The patterns are to be played (?<type_summary>[^.,]+), [^.]+\./
+        		POLYRHYTHM_TYPE_SUMMARY = 'over the same period of time'
+        
+        
+        		# Parses the rhythms from the given form text.
+        		#
+        		# @param form_text [String]
+        		# @return [Hash{Symbol,Rhythm}]
+        		def parse(form_text)
+        			parser = Parser::SectionedText.new(form_text)
+        
+        			simple_rhythms = parse_simple_rhythms(parser)
+        			composite_rhythms = parse_composite_rhythms(parser, simple_rhythms)
+        
+        			simple_rhythms.merge(composite_rhythms)
+        		end
+        
+        		private
+        
+        		# @param parser [Parser::SectionedText]
+        		# @return [Hash{Symbol,Rhythm}]
+        		def parse_simple_rhythms(parser)
+        
+        			rhythms = {}
+        
+        			# Find the rhythm description and the following paragraph with the score.
+        			parser.sections.each_cons(2) do |rhythm, score|
+        				match = SIMPLE_RHYTHM_SENTENCE.match(rhythm)
+        
+        				# Make sure we're actually dealing with a rhythm, not some other form element.
+        				next unless match
+        
+        				rhythms[match[:name].to_sym] = RhythmLine.parse(score)
+        			end
+        
+        			rhythms
+        		end
+        
+        		# @param parser [Parser::SectionedText]
+        		# @param base_rhythms [Hash{Symbol,Rhythm}] Simpler rhythms that can be used by the composite forms we're parsing.
+        		# @return [Hash{Symbol,Rhythm}]
+        		def parse_composite_rhythms(parser, base_rhythms)
+        
+        			composite_rhythms = {}
+        			parser.find_all_paragraphs(COMPOSITE_RHYTHM_SENTENCE).each do |paragraph|
+        
+        				# TODO: write something that handles named matches a bit better
+        				intro_sentence = paragraph.find(COMPOSITE_RHYTHM_SENTENCE).match(COMPOSITE_RHYTHM_SENTENCE)
+        				polyrhythm_name = intro_sentence[:name].to_sym
+        				primary, *secondaries = parse_polyrhythm_components(intro_sentence[:patterns], base_rhythms)
+        
+        				combination_type = paragraph.find(COMBINATION_TYPE_SENTENCE).match(COMBINATION_TYPE_SENTENCE)[:type_summary]
+        
+        				unless combination_type == POLYRHYTHM_TYPE_SUMMARY
+        					raise UnrecognisedFormSyntax.new("Unrecognised polyrhythm type #{combination_type}")
+        				end
+        
+        				composite_rhythms[polyrhythm_name] = Polyrhythm.new(primary, secondaries)
+        			end
+        
+        			composite_rhythms
+        		end
+        
+        		# @param reference_string [String] The list of rhythms used, like "the anto (considered the primary), the tak, ..."
+        		# @param base_rhythms [Hash{Symbol, Rhythm}]
+        		# @return [Array<Rhythm>] The matched rhythms, with the primary one as first element/.
+        		def parse_polyrhythm_components(reference_string, base_rhythms)
+        			primary = nil
+        			secondaries = []
+        
+        			rhythms_with_comments = reference_string.scan(THE_RHYTHM).map do |rhythm_name, comment|
+                                        component = base_rhythms[rhythm_name.to_sym]
+                                        raise(UnknownBaseRhythm.new(rhythm_name)) unless component
+        
+        				[component, comment]
+        			end
+        
+        			primary_rhythms = rhythms_with_comments.select { |_, comment| comment == IS_PRIMARY_COMMENT }
+        
+        			if primary_rhythms.length != 1
+        				raise "Unexpected number of primary rhythms in #{primary_rhythms.inspect}; expected exactly 1"
+        			end
+        			primary = primary_rhythms.first.first
+        
+        			remaining_rhythms = rhythms_with_comments - primary_rhythms
+        			remaining_comments = remaining_rhythms.map(&:last).compact.uniq
+        
+        			if remaining_comments.any?
+        				raise "Unrecognised rhythm comment(s) #{remaining_comments.inspect}"
+        			end
+        
+        			secondaries = remaining_rhythms.select {|_, comment| comment.nil? }.map(&:first)
+        			[primary, *secondaries]
+        		end
+        	end
+        end
+end