fet 0.2.0 → 0.3.0

data/lib/fet/ui/game_setup_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "color_scheme"
+
+module Fet
+  module Ui
+    # Handles setting up the game before starting
+    module GameSetupHelper
+      private
+
+      def setup_window
+        setup_window_title
+        setup_window_background
+        setup_window_event_loop
+        setup_window_update_loop
+      end
+
+      def setup_window_title
+        Ruby2D::Window.set(title: "FET")
+      end
+
+      def setup_window_background
+        Ruby2D::Window.set(background: Fet::Ui::ColorScheme::BLACK)
+      end
+
+      # NOTE: don't test coverage for these methods because this is more of a test of the Ruby2D library
+      # :nocov:
+      def setup_window_event_loop
+        Ruby2D::Window.on(:key_down) do |event|
+          handle_event_loop(event)
+        end
+
+        Ruby2D::Window.on(:mouse_down) do |event|
+          handle_event_loop(event)
+        end
+      end
+      # :nocov:
+
+      # NOTE: don't test coverage for these methods because this is more of a test of the Ruby2D library
+      # :nocov:
+      def setup_window_update_loop
+        Ruby2D::Window.update do
+          handle_update_loop
+        end
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/fet/ui/key.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Fet
+  module Ui
+    # Shows the current level's key in the UI
+    class Key
+      attr_accessor :level
+
+      def initialize(level)
+        self.level = level
+      end
+
+      def start
+        self.text ||= generate_text
+        text.text = text_value
+      end
+
+      private
+
+      attr_accessor :text
+
+      TEXT_SIZE = 36
+      X_OFFSET = 60
+      Y_OFFSET = 90
+      private_constant :TEXT_SIZE, :X_OFFSET, :Y_OFFSET
+
+      def generate_text
+        return Ruby2D::Text.new(
+          text_value,
+          x: X_OFFSET, y: Y_OFFSET,
+          font: File.join(Fet.root, "assets/fonts/PTSans/PTSans-Regular.ttf"),
+          size: TEXT_SIZE,
+          color: ColorScheme::WHITE,
+        )
+      end
+
+      def text_value
+        key_name = level.degrees.root_name
+        key_type = level.game.key_type == "major" ? "Major" : "Minor"
+        return "#{key_name} #{key_type}"
+      end
+    end
+  end
+end

data/lib/fet/ui/level.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "custom_event"
+require_relative "key"
+require_relative "level_loop_handler"
+require_relative "note_boxes"
+
+module Fet
+  module Ui
+    # Holds state for the current level of the game
+    class Level
+      attr_accessor :game, :question_number, :note_boxes, :key, :degrees
+
+      include LevelLoopHandler
+
+      def initialize(game)
+        self.game = game
+        self.question_number = 0
+        self.note_boxes = NoteBoxes.new(self)
+        self.key = Key.new(self)
+      end
+
+      def start
+        start_self
+        note_boxes.start
+        key.start
+
+        # TODO: This is not ideal because we're piggybacking on the normal events at the moment,
+        # but there's no event here to piggyback on, so the handler has to be called manually.
+        game.set_level_started_event_flag
+        game.handle_event_loop(nil)
+      end
+
+      def degree_indices
+        return midi_values.map { |midi_value| degrees.degree_index_of_midi_value(midi_value) }
+      end
+
+      def over?
+        return degree_indices.all? do |degree_index|
+          note_boxes.note_boxes.any? { |note_box| note_box.selected && note_box.degree_index == degree_index }
+        end
+      end
+
+      def answered_correctly?
+        over? && note_boxes.note_boxes.none? { |note_box| note_box.selected && !note_box.correct? }
+      end
+
+      private
+
+      attr_accessor :midi_values, :full_question_music, :chord_progression_music, :notes_music
+
+      def start_self
+        self.question_number += 1
+        self.degrees = generate_degrees
+        self.midi_values = degrees.select_degrees_from_midi_values(game.note_range, game.number_of_degrees)
+
+        update_music_objects
+        play_full_question
+      end
+
+      def play_full_question
+        full_question_music.play
+      end
+
+      def generate_degrees
+        root_midi_values = game.key_type == "major" ? Fet::MAJOR_ROOT_MIDI_VALUES : Fet::MINOR_ROOT_MIDI_VALUES
+        root_name, root_midi_value = root_midi_values.to_a.sample
+        root_octave_value = Fet::MidiNote.new(root_midi_value).octave_number
+        return Degrees.new(root_name: root_name, octave_value: root_octave_value)
+      end
+
+      def update_music_objects
+        self.full_question_music = generate_full_question_music
+        self.chord_progression_music = generate_chord_progression_music
+        self.notes_music = generate_notes_music
+      end
+
+      def generate_full_question_music
+        filename = "tmp/chord_progression_and_question.mid"
+        create_midilib_object("Chord Progression + Question", filename).create_full_question
+        return Ruby2D::Music.new(filename)
+      end
+
+      def generate_chord_progression_music
+        filename = "tmp/chord_progression.mid"
+        create_midilib_object("Chord Progression", filename).create_chord_progression_of_question
+        return Ruby2D::Music.new(filename)
+      end
+
+      def generate_notes_music
+        filename = "tmp/question.mid"
+        create_midilib_object("Question", filename).create_notes_only
+        return Ruby2D::Music.new(filename)
+      end
+
+      def create_midilib_object(info, filename)
+        progression = Fet::ChordProgression.new(offset: degrees.root_midi_value, template_type: game.key_type).with_offset
+        Fet::MidilibInterface.new(
+          tempo: game.tempo,
+          progression: progression,
+          notes: midi_values,
+          info: info,
+          filename: filename,
+        )
+      end
+    end
+  end
+end

data/lib/fet/ui/level_loop_handler.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative "custom_event"
+require_relative "key"
+require_relative "note_boxes"
+
+module Fet
+  module Ui
+    # Handles events for the Level class
+    module LevelLoopHandler
+      def handle_event_loop(event)
+        handle_keyboard_event(event)
+        handle_level_complete_event(event)
+        note_boxes.handle_event_loop(event)
+      end
+
+      def handle_update_loop; end
+
+      private
+
+      def handle_keyboard_event(event)
+        return unless event.is_a?(Ruby2D::Window::KeyEvent)
+        return unless event.type == :down
+
+        handle_c_key if event.key == "c"
+        handle_n_key if event.key == "n"
+        handle_l_key if event.key == "l"
+        handle_return_key if event.key == "return"
+      end
+
+      def handle_c_key
+        chord_progression_music.play
+      end
+
+      def handle_n_key
+        notes_music.play
+      end
+
+      def handle_l_key
+        full_question_music.loop = true
+        full_question_music.play
+      end
+
+      def handle_return_key
+        return unless over?
+
+        start
+      end
+
+      def handle_level_complete_event(event)
+        return unless event.is_a?(CustomEvent) && event.type == CustomEvent::EVENT_TYPE_LEVEL_COMPLETE
+
+        start if answered_correctly? && game.next_on_correct
+      end
+    end
+  end
+end

data/lib/fet/ui/note_box.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "color_scheme"
+require_relative "note_boxes"
+require_relative "note_box_loop_handler"
+
+module Fet
+  module Ui
+    # Handles drawing + events for notes
+    class NoteBox
+      include NoteBoxLoopHandler
+
+      attr_accessor :note_boxes, :degree_name, :selected
+
+      def initialize(note_boxes:, degree_name:)
+        self.note_boxes = note_boxes
+        self.degree_name = degree_name
+      end
+
+      def start
+        self.keyboard_accidental = ""
+        self.square ||= generate_square
+        self.text ||= generate_text
+        self.selected = false
+        self.user_selected = false
+        self.note_music = generate_note_music
+        update_colors
+      end
+
+      def correct?
+        return note_boxes.level.degree_indices.include?(degree_index)
+      end
+
+      def degree_index
+        degree_instance.degree_index
+      end
+
+      private
+
+      attr_accessor :square, :text, :note_music
+
+      NOTE_BOX_SIZE = 70
+      TEXT_SIZE = 36
+      TEXT_X_FOR_NATURAL_OFFSET = 26
+      TEXT_X_FOR_ACCIDENTAL_OFFSET = 16
+      TEXT_Y_OFFSET = 13
+      private_constant :NOTE_BOX_SIZE, :TEXT_SIZE, :TEXT_X_FOR_NATURAL_OFFSET, :TEXT_X_FOR_ACCIDENTAL_OFFSET, :TEXT_Y_OFFSET
+
+      def generate_square
+        return Ruby2D::Square.new(
+          x: NoteBoxes::NOTE_BOX_OFFSETS[degree_name][0],
+          y: NoteBoxes::NOTE_BOX_OFFSETS[degree_name][1],
+          size: NOTE_BOX_SIZE,
+          color: color,
+        )
+      end
+
+      def generate_text
+        return Ruby2D::Text.new(
+          degree_name,
+          x: square.x + text_x_offset, y: square.y + text_y_offset,
+          font: File.join(Fet.root, "assets/fonts/PTSans/PTSans-Regular.ttf"),
+          size: TEXT_SIZE,
+          color: text_color,
+        )
+      end
+
+      def text_x_offset
+        return degree_instance.degree_accidental ? TEXT_X_FOR_ACCIDENTAL_OFFSET : TEXT_X_FOR_NATURAL_OFFSET
+      end
+
+      def text_y_offset
+        return TEXT_Y_OFFSET
+      end
+
+      def degree_instance
+        return Fet::Degree.new(degree_name)
+      end
+
+      def color
+        return correct? ? ColorScheme::GREEN : ColorScheme::RED if selected
+
+        return degree_instance.degree_accidental ? ColorScheme::GREY : ColorScheme::WHITE
+      end
+
+      def text_color
+        case color
+        when ColorScheme::GREY, ColorScheme::GREEN, ColorScheme::RED
+          return ColorScheme::WHITE
+        when ColorScheme::WHITE
+          return ColorScheme::BLACK
+        else
+          raise ImplementationError
+        end
+      end
+
+      def level_over?
+        return note_boxes.level.over?
+      end
+
+      def generate_note_music
+        degrees = note_boxes.level.degrees
+
+        filename = "tmp/#{degree_name}.mid"
+        Fet::MidilibInterface.new(
+          tempo: note_boxes.level.game.tempo,
+          progression: nil,
+          notes: [degrees.root_midi_value + degree_instance.degree_index],
+          info: degree_name,
+          filename: filename,
+        ).create_notes_only
+
+        return Ruby2D::Music.new(filename)
+      end
+    end
+  end
+end

data/lib/fet/ui/note_box_loop_handler.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require_relative "color_scheme"
+require_relative "note_boxes"
+
+module Fet
+  module Ui
+    # Handles events for NoteBox
+    module NoteBoxLoopHandler
+      attr_accessor :user_selected
+
+      def handle_event_loop(event)
+        handle_click_event(event)
+        handle_keyboard_event(event)
+      end
+
+      def handle_update_loop; end
+
+      def manually_select
+        handle_selected(user_selected: false)
+      end
+
+      private
+
+      attr_accessor :keyboard_accidental
+
+      def handle_click_event(event)
+        return unless event.is_a?(Ruby2D::Window::MouseEvent)
+        return unless event.type == :down
+        return unless event.button == :left
+
+        handle_selected if square.contains?(event.x, event.y)
+      end
+
+      def handle_keyboard_event(event)
+        return unless event.is_a?(Ruby2D::Window::KeyEvent)
+        return unless event.type == :down
+
+        input = determine_keyboard_input(event)
+        handle_selected if degree_instance.degree_index == input_degree_instance(input)&.degree_index
+      end
+
+      KEYBOARD_TO_ACCIDENTAL_MAP = {
+        "=" => "#",
+        "0" => "",
+        "-" => "b",
+      }.deep_freeze
+      private_constant :KEYBOARD_TO_ACCIDENTAL_MAP
+
+      def determine_keyboard_input(event)
+        update_keyboard_input_accidental(event)
+        handle_keyboard_input_degree(event)
+      end
+
+      def update_keyboard_input_accidental(event)
+        case event.key
+        when *KEYBOARD_TO_ACCIDENTAL_MAP.keys
+          self.keyboard_accidental = KEYBOARD_TO_ACCIDENTAL_MAP[event.key]
+        when *(1..7).map(&:to_s)
+          # noop
+        else
+          self.keyboard_accidental = ""
+        end
+      end
+
+      def handle_keyboard_input_degree(event)
+        case event.key
+        when *(1..7).map(&:to_s)
+          input = "#{keyboard_accidental}#{event.key}"
+          self.keyboard_accidental = ""
+          return input
+        end
+      end
+
+      def input_degree_instance(input)
+        return nil if input.nil?
+
+        return Fet::Degree.new(input)
+      rescue Fet::InvalidDegreeName
+        # TODO: alterenatively, make degrees like b1 or #1 valid degree names, though that would need a bit of a refactor
+        return nil
+      end
+
+      def handle_selected(user_selected: true)
+        self.keyboard_accidental = ""
+
+        if level_over?
+          play_note
+        else
+          self.user_selected = user_selected
+          self.selected = true
+          update_colors
+          note_boxes.level.game.set_note_selected_event_flag
+        end
+      end
+
+      def play_note
+        note_music.play
+      end
+
+      def update_colors
+        square.color = color
+        text.color = text_color
+      end
+    end
+  end
+end