fet 0.2.0 → 0.3.0

data/lib/fet/exceptions.rb

@@ -13,6 +13,10 @@ module Fet
 
   class InvalidDegreeName < Error; end
 
+  class InvalidCustomEventType < Error; end
+
+  class ImplementationError < Error; end
+
   # TODO: this can be removed if the circle of fifths is generated dynamically
   class UnsupportedRootName < Error; end
 end

data/lib/fet/generator/listening.rb

@@ -29,13 +29,13 @@ module Fet
       def generate_all_single_degree_exercises
         Fet::MAJOR_ROOT_MIDI_VALUES.each do |root|
           note_range.each do |note|
-            select_notes_recursive([note], [], root, 1, "major")
+            select_notes([note], root[0], root[1], 1, "major")
           end
         end
 
         Fet::MINOR_ROOT_MIDI_VALUES.each do |root|
           note_range.each do |note|
-            select_notes_recursive([note], [], root, 1, "minor")
+            select_notes([note], root[0], root[1], 1, "minor")
           end
         end
       end
@@ -43,53 +43,50 @@ module Fet
       def generate_number_of_exercises
         number_of_exercises.times do
           # Create major key exercises
-          root = Fet::MAJOR_ROOT_MIDI_VALUES.to_a.sample
-          until select_notes_recursive(note_range, [], root, number_of_degrees, "major"); end
+          root_name, root_midi_value = Fet::MAJOR_ROOT_MIDI_VALUES.to_a.sample
+          until select_notes(note_range, root_name, root_midi_value, number_of_degrees, "major"); end
 
           # Create minor key exercises
-          root = Fet::MINOR_ROOT_MIDI_VALUES.to_a.sample
-          until select_notes_recursive(note_range, [], root, number_of_degrees, "minor"); end
+          root_name, root_midi_value = Fet::MINOR_ROOT_MIDI_VALUES.to_a.sample
+          until select_notes(note_range, root_name, root_midi_value, number_of_degrees, "minor"); end
         end
       end
 
-      def select_notes_recursive(all_notes, chosen_notes, root, number_degrees, key_type)
-        return create_midi_file(chosen_notes, root, key_type) if number_degrees.zero?
-
-        selected_note = all_notes.sample
-        chosen_notes << selected_note
-
-        all_notes_without_note_degree = all_notes.reject { |note| Fet::MidiNote.new(note).degree(root[1]) == Fet::MidiNote.new(selected_note).degree(root[1]) }
-        select_notes_recursive(all_notes_without_note_degree, chosen_notes, root, number_degrees - 1, key_type)
+      def select_notes(all_notes, root_name, root_midi_value, number_degrees, key_type)
+        root_octave_value = Fet::MidiNote.new(root_midi_value).octave_number
+        degrees_instance = Fet::Degrees.new(root_name: root_name, octave_value: root_octave_value)
+        chosen_notes = degrees_instance.select_degrees_from_midi_values(all_notes, number_degrees)
+        return create_midi_file(chosen_notes, root_name, root_midi_value, key_type)
       end
 
-      def create_midi_file(chosen_notes, root, key_type)
+      def create_midi_file(chosen_notes, root_name, root_midi_value, key_type)
         # Sort so that the file name corresponds to degree of lowest to highest
         chosen_notes = chosen_notes.sort
 
-        filename = full_filename(key_type, root, chosen_notes)
+        filename = full_filename(key_type, root_name, root_midi_value, chosen_notes)
         return false if File.exist?(filename)
 
-        progression = Fet::ChordProgression.new(offset: root[1], template_type: key_type).with_offset
+        progression = Fet::ChordProgression.new(offset: root_midi_value, template_type: key_type).with_offset
         Fet::MidilibInterface.new(
-          tempo: tempo, progression: progression, notes: chosen_notes, info: generate_midi_info(key_type, root, chosen_notes), filename: filename,
+          tempo: tempo, progression: progression, notes: chosen_notes, info: generate_midi_info(key_type, root_name, root_midi_value, chosen_notes), filename: filename,
         ).create_listening_midi_file
         return true
       end
 
-      def generate_midi_info(key_type, root, chosen_notes)
+      def generate_midi_info(key_type, root_name, root_midi_value, chosen_notes)
         return [
-          "Key: [#{root[0]} #{key_type}]",
-          "Degrees: [#{chosen_notes.map { |i| Fet::MusicTheory::DEGREES[(i - root[1]) % 12] }}]",
+          "Key: [#{root_name} #{key_type}]",
+          "Degrees: [#{chosen_notes.map { |i| Fet::MusicTheory::DEGREES[(i - root_midi_value) % 12] }}]",
           "Notes: [#{chosen_notes}]",
         ].join(" ")
       end
 
-      def full_filename(key_type, root, chosen_notes)
+      def full_filename(key_type, root_name, root_midi_value, chosen_notes)
         result = File.join(*[directory_prefix, "listening", key_type].reject(&:empty?))
-        filename = root[0].to_s # note, e.g. Db
+        filename = root_name # note, e.g. Db
         filename += key_type == "major" ? "M" : "m" # type of note, M or m
         filename += "_" # delimiter
-        filename += chosen_notes.map { |i| note_filename_part(root[0], root[1], i) }.join("_") # chosen notes description, e.g. b7(Cb4)
+        filename += chosen_notes.map { |i| note_filename_part(root_name, root_midi_value, i) }.join("_") # chosen notes description, e.g. b7(Cb4)
         filename += ".mid" # extension
         return File.join(result, filename)
       end

data/lib/fet/midi_file_generator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Fet
+  # Use MidilibInterface to create concrete MIDI files
+  module MidiFileGenerator
+    def create_full_question
+      set_progression_on_track
+      add_rest(2 * quarter_note_length)
+      play_notes_as_chord(notes, quarter_note_length)
+      add_rest(3 * quarter_note_length)
+      write_sequence_to_file
+    end
+
+    def create_chord_progression_of_question
+      set_progression_on_track
+      add_rest(1 * quarter_note_length)
+      write_sequence_to_file
+    end
+
+    def create_notes_only
+      play_notes_as_chord(notes, quarter_note_length)
+      add_rest(1 * quarter_note_length)
+      write_sequence_to_file
+    end
+
+    def create_listening_midi_file
+      set_progression_on_track
+
+      add_rest(2 * quarter_note_length)
+      play_notes_as_chord(notes, quarter_note_length)
+
+      add_rest(6 * quarter_note_length)
+      play_notes_sequentially(notes, quarter_note_length)
+
+      write_sequence_to_file
+    end
+
+    def create_singing_midi_file(sleep_duration)
+      set_progression_on_track
+
+      add_seconds_of_rest(sleep_duration)
+      play_notes_sequentially(notes, quarter_note_length)
+      add_rest(3 * quarter_note_length)
+
+      write_sequence_to_file
+    end
+  end
+end

data/lib/fet/midilib_interface.rb

@@ -6,6 +6,8 @@ require "midilib/consts"
 module Fet
   # Interface with the midilib library to generate MIDI files
   class MidilibInterface
+    include MidiFileGenerator
+
     def initialize(tempo:, progression:, notes:, info:, filename:)
       self.tempo = tempo
       self.progression = progression
@@ -16,31 +18,6 @@ module Fet
       self.track = generate_instrument_track
     end
 
-    def create_listening_midi_file
-      # Play the chord progression
-      set_progression_on_track
-
-      add_rest(2 * quarter_note_length)
-      play_notes_as_chord(notes, quarter_note_length)
-
-      add_rest(6 * quarter_note_length)
-      play_notes_sequentially(notes, quarter_note_length)
-
-      write_sequence_to_file
-    end
-
-    def create_singing_midi_file(sleep_duration)
-      # Play the chord progression
-      set_progression_on_track
-
-      # Play the note after waiting for a specified amount of time
-      add_seconds_of_rest(sleep_duration) do
-        play_notes_sequentially(notes, quarter_note_length)
-      end
-
-      write_sequence_to_file
-    end
-
     private
 
     attr_accessor :tempo, :progression, :notes, :info, :filename, :sequence, :track
@@ -56,7 +33,6 @@ module Fet
       with_temporary_tempo_change(60) do
         # Sleep for the requested duration
         add_rest(seconds * quarter_note_length)
-        yield
       end
     end
 

data/lib/fet/score.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Fet
+  # Holds the correct/incorrect answers to questions
+  class Score
+    def initialize
+      self.score = initialize_score
+    end
+
+    def answer_correctly(*degree_indices)
+      degree_indices.each { |degree_index| score[degree_index][:correct] += 1 }
+    end
+
+    def answer_incorrectly(*degree_indices)
+      degree_indices.each { |degree_index| score[degree_index][:incorrect] += 1 }
+    end
+
+    def answered_correctly(degree_index = nil)
+      return score.reduce(0) do |result, (score_degree_index, score_hash)|
+        degree_index.nil? || score_degree_index == degree_index ? result + score_hash[:correct] : result
+      end
+    end
+
+    def answered_incorrectly(degree_index = nil)
+      return score.reduce(0) do |result, (score_degree_index, score_hash)|
+        degree_index.nil? || score_degree_index == degree_index ? result + score_hash[:incorrect] : result
+      end
+    end
+
+    def questions_asked(degree_index = nil)
+      return answered_correctly(degree_index) + answered_incorrectly(degree_index)
+    end
+
+    def as_json(_options = {})
+      score
+    end
+
+    def to_json(*options)
+      as_json(*options).to_json(*options)
+    end
+
+    private
+
+    attr_accessor :score
+
+    def initialize_score
+      Fet::Degree::DEGREE_NAMES.map.with_index { |_, degree_index| [degree_index, { correct: 0, incorrect: 0 }] }.to_h
+    end
+  end
+end

data/lib/fet/ui/color_scheme.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fet
+  module Ui
+    module ColorScheme
+      BLACK = "#151727".deep_freeze
+      GREY = "#393D56".deep_freeze
+      WHITE = "#FAF9F0".deep_freeze
+      RED = "#931621".deep_freeze
+      GREEN = "#2F754E".deep_freeze
+    end
+  end
+end

data/lib/fet/ui/custom_event.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Fet
+  module Ui
+    # Custom events for the event loop
+    class CustomEvent
+      attr_accessor :type
+
+      EVENT_TYPE_NOTE_SELECTED = :note_selected
+      EVENT_TYPE_LEVEL_STARTED = :level_started
+      EVENT_TYPE_LEVEL_COMPLETE = :level_complete
+      EVENT_TYPES = [
+        EVENT_TYPE_NOTE_SELECTED,
+        EVENT_TYPE_LEVEL_STARTED,
+        EVENT_TYPE_LEVEL_COMPLETE,
+      ].deep_freeze
+
+      def initialize(type)
+        self.type = type
+        validate_type!
+      end
+
+      private
+
+      def validate_type!
+        raise InvalidCustomEventType unless EVENT_TYPES.include?(type)
+      end
+    end
+  end
+end
+
+# NOTE: alternatively I started monkey patching the Ruby2D::Window class, though it's probably not the best idea
+# but it WOULD let us call events outside of the standard Ruby2D events.
+# module Ruby2D
+#   class Window
+#     CustomEvent = Struct.new(:type)
+#     @events[:custom] = {}
+#
+#     def custom_callback(type)
+#       @events[:custom].each do |_id, e|
+#         e.call(customEvent.new(type))
+#       end
+#     end
+#   end
+# end

data/lib/fet/ui/game.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "ruby2d"
+require_relative "game_loop_handler"
+require_relative "game_setup_helper"
+require_relative "level"
+require_relative "score"
+require_relative "timer"
+
+module Fet
+  module Ui
+    # Holds the state of the current game
+    class Game
+      include GameSetupHelper
+      include GameLoopHandler
+
+      SCORES_FILENAME = "#{ENV["HOME"]}/.config/fet/scores".deep_freeze
+
+      attr_accessor :level, :score, :timer, :note_range,
+                    :tempo, :number_of_degrees, :key_type, :next_on_correct
+
+      # NOTE: this is explicitly changed in tests, so no need to check for coverage
+      # :nocov:
+      def self.scores_filename
+        return SCORES_FILENAME
+      end
+      # :nocov:
+
+      def initialize(tempo:, degrees:, key_type:, next_on_correct:)
+        self.note_range = Fet::REDUCED_BY_OCTAVE_PIANO_RANGE
+        self.tempo = tempo
+        self.key_type = key_type
+        self.number_of_degrees = degrees
+        self.next_on_correct = next_on_correct
+        self.score = Score.new(self)
+        self.level = Level.new(self)
+        self.timer = Timer.new(self)
+        setup_window
+      end
+
+      def start
+        score.start
+        level.start
+        timer.start
+        show_window
+        write_score_to_file
+      end
+
+      def stop
+        close_window
+      end
+
+      private
+
+      def show_window
+        Ruby2D::Window.show
+      end
+
+      def close_window
+        Ruby2D::Window.close
+      end
+
+      def write_score_to_file
+        new_score_entries = historic_score_entries
+        new_score_entries << current_score_entry
+        directory_name = File.dirname(self.class.scores_filename)
+        FileUtils.mkdir_p(directory_name)
+        File.open(self.class.scores_filename, "w") { |file| file.write(new_score_entries.to_json) }
+      end
+
+      def historic_score_entries
+        result = File.read(self.class.scores_filename)
+        return JSON.parse(result)
+      rescue Errno::ENOENT
+        return []
+      end
+
+      def current_score_entry
+        return {
+          "started_at" => timer.started_at.to_s,
+          "seconds_elapsed" => timer.seconds_elapsed,
+          "score" => score.score,
+        }
+      end
+    end
+  end
+end

data/lib/fet/ui/game_loop_handler.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "custom_event"
+
+module Fet
+  module Ui
+    # Handles various events and updates for the Game object
+    module GameLoopHandler
+      def handle_update_loop
+        score.handle_update_loop
+        level.handle_update_loop
+        timer.handle_update_loop
+      end
+
+      def handle_event_loop(event)
+        handle_keyboard_event(event)
+
+        # NOTE: score must handle event before level because level event could recreate the whole level
+        score.handle_event_loop(event)
+        level.handle_event_loop(event)
+        timer.handle_event_loop(event)
+
+        handle_custom_events
+      end
+
+      def set_note_selected_event_flag
+        self.note_selected_event_flag = true
+      end
+
+      def set_level_started_event_flag
+        self.level_started_event_flag = true
+      end
+
+      def set_level_complete_event_flag
+        self.level_complete_event_flag = true
+      end
+
+      private
+
+      attr_accessor :note_selected_event_flag, :level_started_event_flag, :level_complete_event_flag
+
+      def handle_keyboard_event(event)
+        return unless event.is_a?(Ruby2D::Window::KeyEvent)
+        return unless event.type == :down
+
+        stop if event.key == "q"
+      end
+
+      def handle_custom_events
+        handle_note_selected_event
+        handle_level_started_event
+        handle_level_complete_event
+      end
+
+      def handle_note_selected_event
+        handle_event = note_selected_event_flag
+        self.note_selected_event_flag = false
+        handle_event_loop(CustomEvent.new(CustomEvent::EVENT_TYPE_NOTE_SELECTED)) if handle_event
+      end
+
+      def handle_level_started_event
+        handle_event = level_started_event_flag
+        self.level_started_event_flag = false
+        handle_event_loop(CustomEvent.new(CustomEvent::EVENT_TYPE_LEVEL_STARTED)) if handle_event
+      end
+
+      def handle_level_complete_event
+        handle_event = level_complete_event_flag
+        self.level_complete_event_flag = false
+        handle_event_loop(CustomEvent.new(CustomEvent::EVENT_TYPE_LEVEL_COMPLETE)) if handle_event
+      end
+    end
+  end
+end