mumble_game 1.0.0

data/lib/mumble/layout.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "screen"
+
+module Mumble
+  # Calculates dynamic positions for all game elements based on terminal size
+  # All positions are calculated from center, so game is always centered
+  module Layout
+    # Dimensions for game elements
+    CELL_WIDTH = 5        # Width of a single letter cell (includes border)
+    CELL_HEIGHT = 3       # Height of a single letter cell (includes border)
+    GRID_COLS = 5         # Letters per word
+    GRID_ROWS = 6         # Number of guesses
+    GRID_GAP = 1          # Space between cells
+
+    HANGMAN_WIDTH = 29    # Width of hangman area
+    HANGMAN_HEIGHT = 23   # Height of hangman area
+
+    GAME_SPACING = 8      # Space between grid and hangman
+
+    class << self
+      # Total width of the word grid
+      def grid_width
+        (CELL_WIDTH * GRID_COLS) + (GRID_GAP * (GRID_COLS - 1))
+      end
+
+      # Total height of the word grid
+      def grid_height
+        (CELL_HEIGHT * GRID_ROWS) + (GRID_GAP * (GRID_ROWS - 1))
+      end
+
+      # Total width of the entire game area (grid + spacing + hangman)
+      def game_width
+        grid_width + GAME_SPACING + HANGMAN_WIDTH
+      end
+
+      # Total height of the game area (including header and footer)
+      def game_height
+        [grid_height, HANGMAN_HEIGHT].max + 6 # +6 for header, footer, spacing
+      end
+
+      # Starting column for the entire game area (left edge)
+      def game_start_col
+        Screen.center_col(game_width)
+      end
+
+      # Starting row for the entire game area (top edge)
+      def game_start_row
+        [(Screen.height - game_height) / 2, 2].max
+      end
+
+      # --- HEADER POSITIONS ---
+
+      # Level display position (centered at top)
+      def level_row
+        game_start_row
+      end
+
+      def level_col
+        Screen.center_col(15) # "━━━ LEVEL XX ━━━" is about 15 chars
+      end
+
+      # Timer position (top right of game area)
+      def timer_row
+        game_start_row
+      end
+
+      def timer_col
+        game_start_col + game_width - 10 # "⏱️  0:00" is about 10 chars
+      end
+
+      # --- GRID POSITIONS ---
+
+      # Top-left corner of the word grid
+      def grid_row
+        game_start_row + 3 # Below header
+      end
+
+      def grid_col
+        game_start_col
+      end
+
+      # Get position for a specific cell in the grid
+      # cell_row: 0-5 (which guess row)
+      # cell_col: 0-4 (which letter position)
+      def cell_position(cell_row, cell_col)
+        row = grid_row + (cell_row * (CELL_HEIGHT + GRID_GAP))
+        col = grid_col + (cell_col * (CELL_WIDTH + GRID_GAP))
+        { row: row, col: col }
+      end
+
+      # --- HANGMAN POSITIONS ---
+
+      # Top-left corner of the hangman area
+      def hangman_row
+        grid_row
+      end
+
+      def hangman_col
+        grid_col + grid_width + GAME_SPACING
+      end
+
+      # Used letters display (below hangman)
+      def used_letters_row
+        hangman_row + HANGMAN_HEIGHT + 1
+      end
+
+      def used_letters_col
+        hangman_col
+      end
+
+      # --- INPUT/MESSAGE POSITIONS ---
+
+      # Input prompt position (below grid)
+      def input_row
+        grid_row + grid_height + 2
+      end
+
+      def input_col
+        grid_col
+      end
+
+      # Message area (for errors, hints)
+      def message_row
+        input_row + 2
+      end
+
+      def message_col
+        game_start_col
+      end
+
+      # --- UTILITY METHODS ---
+
+      # Check if terminal can fit the game
+      def fits?
+        Screen.width >= game_width + 4 && Screen.height >= game_height + 2
+      end
+
+      # Get a summary of all positions (useful for debugging)
+      def debug_info
+        {
+          screen: { width: Screen.width, height: Screen.height },
+          game_area: { width: game_width, height: game_height },
+          game_start: { row: game_start_row, col: game_start_col },
+          grid_start: { row: grid_row, col: grid_col },
+          hangman_start: { row: hangman_row, col: hangman_col },
+          input: { row: input_row, col: input_col },
+          fits: fits?
+        }
+      end
+
+      # --- SCALING SYSTEM ---
+
+      # Terminal size categories
+      def size_category
+        if Screen.width >= 160 && Screen.height >= 45
+          :large
+        elsif Screen.width >= 100 && Screen.height >= 30
+          :medium
+        else
+          :small
+        end
+      end
+
+      # Scale factor based on terminal size (1.0 = baseline at 80x24)
+      def scale_factor
+        width_scale = Screen.width / 80.0
+        height_scale = Screen.height / 24.0
+        [width_scale, height_scale].min.clamp(1.0, 2.5)
+      end
+
+      # Scale a value based on terminal size
+      def scale(value)
+        (value * scale_factor).round
+      end
+
+      # Get scaled box dimensions for menus
+      def menu_box_width
+        case size_category
+        when :large then 50
+        when :medium then 40
+        else 30
+        end
+      end
+
+      def menu_box_padding
+        case size_category
+        when :large then 3
+        when :medium then 2
+        else 1
+        end
+      end
+
+      def menu_item_spacing
+        case size_category
+        when :large then 2
+        when :medium then 1
+        else 0
+        end
+      end
+
+      # Should we use the big logo?
+      def use_large_logo?
+        %i[large medium].include?(size_category)
+      end
+    end
+  end
+end

data/lib/mumble/scorer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Mumble
+  # Calculates game scores based on performance
+  module Scorer
+    # Base points for winning
+    BASE_SCORE = 1000
+
+    # Points deducted per guess used
+    GUESS_PENALTY = 100
+
+    # Points deducted per 30 seconds
+    TIME_PENALTY = 50
+
+    # Bonus multiplier per level
+    LEVEL_MULTIPLIER = 0.1
+
+    class << self
+      # Calculate score for a winning game
+      # guesses: number of guesses used (1-6)
+      # time: seconds taken to complete
+      # level: current level (for multiplier)
+      def calculate(guesses:, time:, level:)
+        return 0 if guesses > 6
+
+        # Start with base score
+        score = BASE_SCORE
+
+        # Deduct for guesses used (first guess is free)
+        guess_deduction = (guesses - 1) * GUESS_PENALTY
+        score -= guess_deduction
+
+        # Deduct for time taken (every 30 seconds)
+        time_blocks = (time / 30.0).floor
+        time_deduction = time_blocks * TIME_PENALTY
+        score -= time_deduction
+
+        # Apply level multiplier (10% bonus per level after 1)
+        if level > 1
+          multiplier = 1 + ((level - 1) * LEVEL_MULTIPLIER)
+          score = (score * multiplier).round
+        end
+
+        # Never go below 100 for a win
+        [score, 100].max
+      end
+
+      # Get a breakdown of the score calculation
+      def breakdown(guesses:, time:, level:)
+        guess_deduction = (guesses - 1) * GUESS_PENALTY
+        time_blocks = (time / 30.0).floor
+        time_deduction = time_blocks * TIME_PENALTY
+        multiplier = level > 1 ? 1 + ((level - 1) * LEVEL_MULTIPLIER) : 1.0
+
+        base = BASE_SCORE - guess_deduction - time_deduction
+        final = [(base * multiplier).round, 100].max
+
+        {
+          base_score: BASE_SCORE,
+          guess_penalty: -guess_deduction,
+          time_penalty: -time_deduction,
+          level_multiplier: multiplier,
+          final_score: final
+        }
+      end
+
+      # Get rating based on score
+      def rating(score)
+        case score
+        when 900.. then "⭐⭐⭐ PERFECT!"
+        when 700..899 then "⭐⭐ GREAT!"
+        when 500..699 then "⭐ GOOD"
+        else "NICE TRY"
+        end
+      end
+    end
+  end
+end

data/lib/mumble/screen.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "tty-screen"
+
+module Mumble
+  # Handles terminal screen dimensions and validation
+  module Screen
+    # Minimum dimensions required for the game
+    MIN_WIDTH = 80
+    MIN_HEIGHT = 24
+
+    class << self
+      # Get current terminal width
+      def width
+        TTY::Screen.width
+      end
+
+      # Get current terminal height
+      def height
+        TTY::Screen.height
+      end
+
+      # Check if terminal meets minimum size requirements
+      def valid_size?
+        width >= MIN_WIDTH && height >= MIN_HEIGHT
+      end
+
+      # Get current dimensions as a hash
+      def dimensions
+        { width: width, height: height }
+      end
+
+      # Calculate horizontal center position for text of given length
+      def center_col(text_length)
+        [(width - text_length) / 2, 1].max
+      end
+
+      # Calculate vertical center position
+      def center_row
+        height / 2
+      end
+
+      # Attempt to resize terminal (works on some terminals)
+      # Returns true if resize was attempted
+      def attempt_resize
+        print "\e[8;#{MIN_HEIGHT};#{MIN_WIDTH}t"
+        true
+      end
+
+      # Get a friendly size description
+      def size_description
+        "#{width}x#{height}"
+      end
+
+      # Get required size description
+      def required_size_description
+        "#{MIN_WIDTH}x#{MIN_HEIGHT}"
+      end
+    end
+  end
+end

data/lib/mumble/screens/base.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Mumble
+  module Screens
+    # Base class for all game screens
+    # Provides common functionality and structure
+    class Base
+      attr_reader :config
+
+      def initialize(config = nil)
+        @config = config || Config.load
+      end
+
+      # Main entry point - override in subclasses
+      def show
+        raise NotImplementedError, "Subclasses must implement #show"
+      end
+
+      private
+
+      # Clear screen and prepare for drawing
+      def setup_screen
+        Cursor.clear_screen
+        Cursor.hide
+      end
+
+      # Restore cursor before leaving screen
+      def cleanup_screen
+        Cursor.show
+      end
+
+      # Draw centered text at a specific row
+      def draw_centered(row, text, color: nil)
+        col = Screen.center_col(text.length)
+        Cursor.move_to(row, col)
+        print color ? Colors.send(color, text) : text
+      end
+
+      # Draw text at specific position
+      def draw_at(row, col, text, color: nil)
+        Cursor.move_to(row, col)
+        if color
+          colored_text = if Colors.respond_to?(color)
+                           Colors.send(color, text)
+                         else
+                           text
+                         end
+          print colored_text
+        else
+          print text
+        end
+      end
+
+      # Wait for user to press any key
+      def wait_for_key
+        Input.wait_for_any_key
+      end
+
+      # Wait for user to press Enter
+      def wait_for_enter
+        Input.wait_for_enter
+      end
+
+      # Get player name from config
+      def player_name
+        config[:player_name]
+      end
+
+      # Short pause for animations
+      def pause(seconds = 0.5)
+        sleep(seconds)
+      end
+
+      # Truncate text to fit within max length
+      def truncate(text, max_length, suffix: "...")
+        return text if text.length <= max_length
+
+        text[0, max_length - suffix.length] + suffix
+      end
+
+      # --- SCALING HELPERS ---
+
+      # Get current size category
+      def size_category
+        Layout.size_category
+      end
+
+      # Check if large terminal
+      def large_screen?
+        size_category == :large
+      end
+
+      # Check if medium or larger terminal
+      def medium_screen?
+        %i[large medium].include?(size_category)
+      end
+
+      # Get scaled value
+      def scale(value)
+        Layout.scale(value)
+      end
+
+      # Get menu box width
+      def box_width
+        Layout.menu_box_width
+      end
+
+      # Get item spacing for menus
+      def item_spacing
+        Layout.menu_item_spacing
+      end
+
+      # Get box padding
+      def box_padding
+        Layout.menu_box_padding
+      end
+
+      # Draw a horizontal divider line (centered)
+      def draw_divider(row, width: nil, color: :dim)
+        w = width || box_width
+        line = "─" * w
+        draw_centered(row, line, color: color)
+      end
+
+      # Draw a box centered on screen
+      def draw_centered_box(row:, width:, height:, color: :dim, title: nil)
+        col = Screen.center_col(width)
+        if title
+          Box.draw_with_title(row: row, col: col, width: width, height: height, title: title, color: color)
+        else
+          Box.draw(row: row, col: col, width: width, height: height, color: color)
+        end
+        { row: row, col: col, width: width, height: height }
+      end
+
+      # Calculate vertical center offset for content of given height
+      def center_row_for(content_height)
+        Screen.center_row - (content_height / 2)
+      end
+    end
+  end
+end