mumble_game 1.0.0

data/lib/mumble/screens/gameplay.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../grid"
+require_relative "../hangman"
+
+module Mumble
+  module Screens
+    # Main gameplay screen - ties together grid, hangman, timer, and input
+    class Gameplay < Base
+      def initialize(level:, target_word:)
+        super()
+        @level = level
+        @target_word = target_word.upcase
+        @guesses = []           # Array of guess results
+        @current_input = ""     # What user is typing
+        @wrong_count = 0        # Hangman stage (0-6)
+        @used_letters = {}      # letter => :correct, :present, :absent
+        @start_time = nil       # Timer starts when game begins
+        @game_over = false
+        @won = false
+        @timer_thread = nil
+      end
+
+      def show
+        Cursor.hide
+        draw_screen
+
+        # Main game loop
+        game_loop until @game_over
+
+        # Stop background timer
+        stop_timer_thread
+
+        # Show final state and wait for keypress
+        draw_screen
+        Input.wait_for_any_key
+
+        # Return result for game loop to handle
+        { won: @won, level: @level, guesses: @guesses.length, time: elapsed_time }
+      end
+
+      private
+
+      # --- MAIN GAME LOOP ---
+
+      def game_loop
+        # Start timer immediately when game begins
+        @start_time ||= Time.now
+
+        # Start background timer thread if not already running
+        start_timer_thread unless @timer_thread&.alive?
+
+        # Read input (blocking)
+        char = Input.read_key
+
+        return unless char
+
+        handle_input(char)
+      end
+
+      # Background thread to update timer display
+      def start_timer_thread
+        @timer_thread = Thread.new do
+          loop do
+            sleep(1)
+            break if @game_over
+
+            update_timer_display
+          end
+        end
+      end
+
+      # Stop the timer thread
+      def stop_timer_thread
+        @timer_thread&.kill
+        @timer_thread = nil
+      end
+
+      def handle_input(char)
+        case char
+        when :enter
+          submit_guess if @current_input.length == 5
+        when :backspace
+          handle_backspace
+        when :escape
+          # Could add pause menu later
+          nil
+        else
+          handle_character(char)
+        end
+      end
+
+      def handle_character(char)
+        # Only accept letters, max 5 characters
+        return unless char.is_a?(String) && char.match?(/\A[a-zA-Z]\z/)
+        return if @current_input.length >= 5
+
+        @current_input += char.upcase
+        redraw_current_row
+      end
+
+      def handle_backspace
+        return if @current_input.empty?
+
+        @current_input = @current_input[0...-1]
+        redraw_current_row
+      end
+
+      def submit_guess
+        return if @current_input.length != 5
+
+        # Process the guess and get colored result
+        result = process_guess(@current_input)
+
+        # Animate the letter reveal
+        animate_letter_reveal(result)
+
+        # Clear input for next row
+        @current_input = ""
+
+        # Redraw to show results
+        draw_screen
+      end
+
+      # Animate each letter revealing with color
+      def animate_letter_reveal(result)
+        row_index = @guesses.length - 1 # Just added, so -1
+        base_row = grid_row + (row_index * (Grid.dimensions[:cell_height] + Grid.dimensions[:v_gap]))
+
+        result.each_with_index do |letter_result, col_index|
+          cell_col = grid_col + (col_index * (Grid.dimensions[:cell_width] + Grid.dimensions[:h_gap]))
+
+          # Brief flash white before showing color
+          Grid.draw_cell(row: base_row, col: cell_col, letter: letter_result[:letter], state: :typing)
+          sleep(0.1)
+
+          # Reveal with actual color
+          Grid.draw_cell(row: base_row, col: cell_col, letter: letter_result[:letter], state: letter_result[:state])
+          sleep(0.15)
+        end
+      end
+
+      # --- LAYOUT CALCULATIONS ---
+
+      def game_width
+        case Layout.size_category
+        when :large
+          Grid.total_width + spacing_between + Hangman.width + 20
+        else
+          Grid.total_width + spacing_between + Hangman.width + 10
+        end
+      end
+
+      def game_height
+        case Layout.size_category
+        when :large
+          Grid.total_height + 10
+        else
+          Grid.total_height + 8
+        end
+      end
+
+      def game_start_row
+        (Screen.height - game_height) / 2
+      end
+
+      def game_start_col
+        (Screen.width - game_width) / 2
+      end
+
+      def content_start_row
+        game_start_row + 4
+      end
+
+      def grid_col
+        case Layout.size_category
+        when :large
+          game_start_col + 5
+        else
+          game_start_col + 2
+        end
+      end
+
+      def grid_row
+        content_start_row
+      end
+
+      def hangman_col
+        grid_col + Grid.total_width + spacing_between
+      end
+
+      def hangman_row
+        content_start_row
+      end
+
+      def spacing_between
+        case Layout.size_category
+        when :large
+          12
+        else
+          6
+        end
+      end
+
+      def used_letters_row
+        hangman_row + Hangman.height + 2
+      end
+
+      def used_letters_col
+        hangman_col
+      end
+
+      def input_row
+        grid_row + Grid.total_height + 2
+      end
+
+      def input_col
+        grid_col
+      end
+
+      def timer_row
+        game_start_row + 2
+      end
+
+      def timer_col
+        hangman_col
+      end
+
+      # --- DRAWING METHODS ---
+
+      def draw_screen
+        Cursor.clear_screen
+        draw_game_border
+        draw_level_header
+        draw_timer
+        draw_grid
+        draw_hangman
+        draw_used_letters
+        draw_input_prompt
+      end
+
+      # Redraw only the current row being typed (for performance)
+      def redraw_current_row
+        Grid.draw_row(
+          row: grid_row + (@guesses.length * (Grid.dimensions[:cell_height] + Grid.dimensions[:v_gap])),
+          col: grid_col,
+          letters: [],
+          is_current: true,
+          current_input: @current_input
+        )
+        redraw_input_prompt
+      end
+
+      # Redraw just the input prompt area
+      def redraw_input_prompt
+        # Clear the line first
+        Cursor.move_to(input_row, input_col)
+        print " " * 50
+        Cursor.move_to(input_row + 1, input_col)
+        print " " * 50
+        draw_input_prompt
+      end
+
+      # Update timer without full redraw
+      def update_timer_display
+        Cursor.move_to(timer_row, timer_col)
+        print " " * 15 # Clear previous
+        Cursor.move_to(timer_row, timer_col)
+        time_text = "Time: #{format_time(elapsed_time)}"
+        print Colors.dim(time_text)
+      end
+
+      def draw_game_border
+        Box.draw(
+          row: game_start_row,
+          col: game_start_col,
+          width: game_width,
+          height: game_height,
+          color: :dim
+        )
+      end
+
+      def draw_level_header
+        text = "═══ LEVEL #{@level} ═══"
+        draw_centered(game_start_row + 1, text, color: :cyan)
+      end
+
+      def draw_timer
+        time_text = "Time: #{format_time(elapsed_time)}"
+        draw_at(timer_row, timer_col, time_text, color: :dim)
+      end
+
+      def format_time(seconds)
+        mins = seconds / 60
+        secs = seconds % 60
+        format("%d:%02d", mins, secs)
+      end
+
+      def elapsed_time
+        return 0 unless @start_time
+
+        (Time.now - @start_time).to_i
+      end
+
+      def draw_grid
+        Grid.draw(
+          row: grid_row,
+          col: grid_col,
+          guesses: @guesses,
+          current_row: @guesses.length,
+          current_input: @current_input
+        )
+      end
+
+      def draw_hangman
+        Hangman.draw(
+          row: hangman_row,
+          col: hangman_col,
+          stage: @wrong_count
+        )
+      end
+
+      def draw_used_letters
+        return if @used_letters.empty?
+
+        draw_at(used_letters_row, used_letters_col, "Used Letters:", color: :dim)
+
+        row_offset = 1
+        letters_per_row = Layout.size_category == :large ? 13 : 9
+
+        @used_letters.keys.sort.each_slice(letters_per_row).with_index do |letter_group, index|
+          col = used_letters_col
+          Cursor.move_to(used_letters_row + row_offset + index, col)
+
+          letter_group.each do |letter|
+            state = @used_letters[letter]
+            color = case state
+                    when :correct then :green
+                    when :present then :orange
+                    else :red
+                    end
+            print Colors.send(color, "#{letter} ")
+          end
+        end
+      end
+
+      def draw_input_prompt
+        if @game_over
+          if @won
+            draw_at(input_row, input_col, "🎉 Correct! Press any key...", color: :green)
+          else
+            draw_at(input_row, input_col, "The word was: #{@target_word}", color: :red)
+            draw_at(input_row + 1, input_col, "Press any key to continue...", color: :dim)
+          end
+        else
+          # Show current input with cursor indicator
+          display_input = @current_input.ljust(5, "_")
+          prompt = "Enter guess: #{display_input}"
+          draw_at(input_row, input_col, prompt, color: :white)
+
+          # Hint text
+          hint = if @current_input.length < 5
+                   "(Type #{5 - @current_input.length} more letter#{"s" if 5 - @current_input.length > 1})"
+                 else
+                   "(Press ENTER to submit)"
+                 end
+          draw_at(input_row + 1, input_col, hint, color: :dim)
+        end
+      end
+
+      # --- GAME LOGIC ---
+
+      # NOTE: Two passes are intentional - Wordle scoring requires finding exact matches
+      # first, then checking remaining letters against what's left in the target word.
+
+      # rubocop:disable Style/CombinableLoops
+      def process_guess(guess)
+        guess = guess.upcase
+        result = []
+        target_letters = @target_word.chars
+        guess_letters = guess.chars
+
+        # First pass: mark correct positions
+        guess_letters.each_with_index do |letter, i|
+          if letter == target_letters[i]
+            result[i] = { letter: letter, state: :correct }
+            target_letters[i] = nil
+          end
+        end
+
+        # Second pass: mark present/absent
+        guess_letters.each_with_index do |letter, i|
+          next if result[i]
+
+          target_index = target_letters.index(letter)
+          if target_index
+            result[i] = { letter: letter, state: :present }
+            target_letters[target_index] = nil
+          else
+            result[i] = { letter: letter, state: :absent }
+          end
+        end
+        # rubocop:enable Style/CombinableLoops
+
+        # Update used letters tracking
+        result.each do |r|
+          existing = @used_letters[r[:letter]]
+          next unless existing.nil? ||
+                      (existing == :absent && r[:state] != :absent) ||
+                      (existing == :present && r[:state] == :correct)
+
+          @used_letters[r[:letter]] = r[:state]
+        end
+
+        # Add to guesses
+        @guesses << result
+
+        # Check win condition
+        if result.all? { |r| r[:state] == :correct }
+          @won = true
+          @game_over = true
+        # Check lose condition - wrong guess increments hangman
+        elsif result.any? { |r| r[:state] != :correct }
+          @wrong_count += 1
+          @game_over = true if @wrong_count >= 6 || @guesses.length >= 6
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/mumble/screens/high_scores.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Mumble
+  module Screens
+    # High scores leaderboard display
+    class HighScoresScreen < Base
+      def show
+        setup_screen
+        draw_leaderboard
+        wait_for_key
+        cleanup_screen
+      end
+
+      private
+
+      def content_width
+        case size_category
+        when :large then 70
+        when :medium then 60
+        else 52
+        end
+      end
+
+      def content_height
+        case size_category
+        when :large then 20
+        when :medium then 18
+        else 16
+        end
+      end
+
+      def start_row
+        center_row_for(content_height)
+      end
+
+      def draw_leaderboard
+        box = draw_centered_box(
+          row: start_row,
+          width: content_width,
+          height: content_height,
+          title: "HIGH SCORES",
+          color: :yellow
+        )
+
+        col = box[:col]
+        row = box[:row]
+
+        scores = HighScores.all
+
+        if scores.empty?
+          draw_empty_state(row)
+        else
+          draw_header_row(row + 2, col)
+          draw_scores(row + 3, col, scores)
+          draw_player_best(row + content_height - 2, col)
+        end
+
+        # Prompt
+        prompt_row = row + content_height + 1
+        draw_centered(prompt_row, "Press any key to continue...", color: :dim)
+      end
+
+      def draw_empty_state(row)
+        empty_row = row + (content_height / 2) - 1
+        draw_centered(empty_row, "No high scores yet!", color: :dim)
+        draw_centered(empty_row + 2, "Play a game to get on the leaderboard!", color: :yellow)
+      end
+
+      def draw_header_row(row, col)
+        draw_at(row, col + 3, "RANK", color: :dim)
+        draw_at(row, col + 10, "NAME", color: :dim)
+        draw_at(row, col + 28, "SCORE", color: :dim)
+        draw_at(row, col + 38, "LVL", color: :dim)
+        draw_at(row, col + 44, "DATE", color: :dim)
+      end
+
+      def draw_scores(start_row, col, scores)
+        scores.first(10).each_with_index do |score, index|
+          row = start_row + index
+          rank = index + 1
+
+          # Rank with medal for top 3
+          rank_text, rank_color = format_rank(rank)
+          draw_at(row, col + 3, rank_text, color: rank_color)
+
+          # Name (truncate if needed)
+          name = truncate(score[:name].to_s, 14)
+          name_color = score[:name] == player_name ? :cyan : :white
+          draw_at(row, col + 10, name, color: name_color)
+
+          # Score
+          score_text = format_score(score[:score])
+          draw_at(row, col + 28, score_text, color: :white)
+
+          # Level
+          draw_at(row, col + 38, score[:level].to_s, color: :dim)
+
+          # Date
+          date = score[:date].to_s[0, 10]
+          draw_at(row, col + 44, date, color: :dim)
+        end
+      end
+
+      def draw_player_best(row, col)
+        best_rank = HighScores.best_rank_for(player_name)
+        return unless best_rank
+
+        best = HighScores.best_score_for(player_name)
+        draw_at(row, col + 3, "Your best: ##{best_rank} with #{best[:score]} pts", color: :cyan)
+      end
+
+      def format_rank(rank)
+        case rank
+        when 1 then ["1st", :bold_yellow]
+        when 2 then ["2nd", :white]
+        when 3 then ["3rd", :red]
+        else ["#{rank}th", :dim]
+        end
+      end
+
+      def format_score(score)
+        score.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+      end
+    end
+  end
+end

data/lib/mumble/screens/lose.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mumble
+  module Screens
+    # Game over screen with flashing text
+    class Lose < Base
+      GAME_OVER_SMALL = [
+        "╔═╗╔═╗╔╦╗╔═╗  ╔═╗╦  ╦╔═╗╦═╗",
+        "║ ╦╠═╣║║║║╣   ║ ║╚╗╔╝║╣ ╠╦╝",
+        "╚═╝╩ ╩╩ ╩╚═╝  ╚═╝ ╚╝ ╚═╝╩╚═"
+      ].freeze
+
+      GAME_OVER_LARGE = [
+        "██████╗  █████╗ ███╗   ███╗███████╗     ██████╗ ██╗   ██╗███████╗██████╗ ",
+        "██╔════╝ ██╔══██╗████╗ ████║██╔════╝    ██╔═══██╗██║   ██║██╔════╝██╔══██╗",
+        "██║  ███╗███████║██╔████╔██║█████╗      ██║   ██║██║   ██║█████╗  ██████╔╝",
+        "██║   ██║██╔══██║██║╚██╔╝██║██╔══╝      ██║   ██║╚██╗ ██╔╝██╔══╝  ██╔══██╗",
+        "╚██████╔╝██║  ██║██║ ╚═╝ ██║███████╗    ╚██████╔╝ ╚████╔╝ ███████╗██║  ██║",
+        "╚═════╝ ╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝     ╚═════╝   ╚═══╝  ╚══════╝╚═╝  ╚═╝"
+      ].freeze
+
+      def initialize(word:, level:, guesses:)
+        super()
+        @word = word
+        @level = level
+        @guesses = guesses
+      end
+
+      def show
+        Cursor.hide
+        draw_screen
+        flash_game_over
+        Input.wait_for_any_key
+      end
+
+      private
+
+      def game_over_text
+        Layout.size_category == :large ? GAME_OVER_LARGE : GAME_OVER_SMALL
+      end
+
+      def text_start_row
+        (Screen.height - 25) / 2
+      end
+
+      def text_start_col
+        Screen.center_col(game_over_text.first.length)
+      end
+
+      def draw_screen
+        Cursor.clear_screen
+        draw_game_over_text(:red)
+        draw_content
+      end
+
+      def draw_game_over_text(color)
+        game_over_text.each_with_index do |line, index|
+          Cursor.move_to(text_start_row + index, text_start_col)
+          print Colors.send(color, line)
+        end
+      end
+
+      def flash_game_over
+        # Flash between red and dim red
+        6.times do
+          draw_game_over_text(:red)
+          pause(0.3)
+          draw_game_over_text(:dim)
+          pause(0.2)
+        end
+        # End on solid red
+        draw_game_over_text(:red)
+      end
+
+      def draw_content
+        content_row = text_start_row + game_over_text.length + 3
+
+        # Skull emoji line
+        draw_centered(content_row, "💀 💀 💀", color: :red)
+
+        # Word revealed
+        draw_centered(content_row + 3, "The word was:", color: :dim)
+        draw_centered(content_row + 5, @word, color: :cyan)
+
+        # Stats
+        draw_centered(content_row + 8, "Level: #{@level}  |  Guesses: #{@guesses}/6", color: :dim)
+
+        # Encouragement
+        messages = [
+          "Better luck next time!",
+          "Don't give up!",
+          "You'll get it next time!",
+          "Practice makes perfect!"
+        ]
+        draw_centered(content_row + 11, messages.sample, color: :yellow)
+
+        # Continue prompt
+        draw_centered(content_row + 14, "Press any key to continue...", color: :dim)
+      end
+
+      def pause(seconds)
+        sleep(seconds)
+      end
+    end
+  end
+end