mumble_game 1.0.0

data/lib/mumble/config.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "storage"
+require_relative "error_handler"
+
+module Mumble
+  # Manages player profile, preferences, and statistics
+  module Config
+    FILENAME = "config.json"
+
+    # Default values for a new player
+    DEFAULTS = {
+      player_name: "Player",
+      created_at: nil,
+      updated_at: nil,
+      preferences: {
+        skip_rules: false,
+        show_timer: true
+      },
+      stats: {
+        games_played: 0,
+        games_won: 0,
+        current_streak: 0,
+        best_streak: 0,
+        highest_level: 0,
+        total_score: 0
+      }
+    }.freeze
+
+    class << self
+      # Load config with corruption recovery
+      def load
+        return create_new_config unless exists?
+
+        data = Storage.read_json(FILENAME)
+
+        # Validate the loaded data
+        unless valid_config?(data)
+          backup_corrupted_config
+          return create_new_config
+        end
+
+        merge_with_defaults(data)
+      rescue StandardError => e
+        ErrorHandler.log_error(e, "Config load failed")
+        backup_corrupted_config
+        create_new_config
+      end
+
+      # Check if config data is valid
+      def valid_config?(data)
+        return false unless data.is_a?(Hash)
+        return false unless data[:player_name].is_a?(String)
+        return false unless data[:stats].is_a?(Hash)
+
+        true
+      end
+
+      # Backup corrupted config before replacing
+      def backup_corrupted_config
+        return unless exists?
+
+        backup_name = "config.backup.#{Time.now.to_i}.json"
+        Storage.write_json(backup_name, Storage.read_json(FILENAME))
+      rescue StandardError
+        # If backup fails, just continue
+        nil
+      end
+
+      # Save config to file
+      def save(config)
+        config[:updated_at] = Time.now.iso8601
+        Storage.write_json(FILENAME, config)
+      end
+
+      # Check if a config file exists (returning player vs new player)
+      def exists?
+        Storage.file_exists?(FILENAME)
+      end
+
+      # Create a new config with defaults
+      def create_new_config
+        config = deep_copy(DEFAULTS)
+        config[:created_at] = Time.now.iso8601
+        config[:updated_at] = Time.now.iso8601
+        config
+      end
+
+      # Update player name
+      def update_name(config, new_name)
+        config[:player_name] = sanitize_name(new_name)
+        save(config)
+        config
+      end
+
+      # Update a preference
+      def update_preference(config, key, value)
+        config[:preferences][key] = value
+        save(config)
+        config
+      end
+
+      # Record a game result
+      def record_game(config, won:, score:, level:)
+        stats = config[:stats]
+
+        stats[:games_played] += 1
+
+        if won
+          stats[:games_won] += 1
+          stats[:current_streak] += 1
+          stats[:best_streak] = [stats[:best_streak], stats[:current_streak]].max
+          stats[:total_score] += score
+        else
+          stats[:current_streak] = 0
+        end
+
+        stats[:highest_level] = [stats[:highest_level], level].max
+
+        save(config)
+        config
+      end
+
+      # Reset all statistics
+      def reset_stats(config)
+        config[:stats] = deep_copy(DEFAULTS[:stats])
+        save(config)
+        config
+      end
+
+      # Delete all config data
+      def delete
+        Storage.delete_file(FILENAME)
+      end
+
+      # Calculate win rate as a percentage
+      def win_rate(config)
+        played = config[:stats][:games_played]
+        return 0 if played.zero?
+
+        ((config[:stats][:games_won].to_f / played) * 100).round
+      end
+
+      private
+
+      # Sanitize player name
+      def sanitize_name(name)
+        sanitized = name.to_s.strip[0, 20]
+        sanitized.empty? ? "Player" : sanitized
+      end
+
+      # Deep copy a hash (so we don't modify DEFAULTS)
+      def deep_copy(hash)
+        JSON.parse(JSON.generate(hash), symbolize_names: true)
+      end
+
+      # Merge loaded data with defaults (handles missing keys)
+      def merge_with_defaults(data)
+        config = deep_copy(DEFAULTS)
+
+        config[:player_name] = data[:player_name] if data[:player_name]
+        config[:created_at] = data[:created_at] if data[:created_at]
+        config[:updated_at] = data[:updated_at] if data[:updated_at]
+
+        config[:preferences].merge!(data[:preferences]) if data[:preferences]
+        config[:stats].merge!(data[:stats]) if data[:stats]
+
+        config
+      end
+    end
+  end
+end

data/lib/mumble/cursor.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "tty-cursor"
+
+module Mumble
+  # Provides cursor control for terminal manipulation
+  # Uses TTY::Cursor for cross-platform support
+  module Cursor
+    class << self
+      # Memoized cursor instance
+      def cursor
+        @cursor ||= TTY::Cursor
+      end
+
+      # Move cursor to specific row and column (1-indexed)
+      def move_to(row, col)
+        print cursor.move_to(col - 1, row - 1)
+      end
+
+      # Move cursor up by n rows
+      def up(n = 1)
+        print cursor.up(n)
+      end
+
+      # Move cursor down by n rows
+      def down(n = 1)
+        print cursor.down(n)
+      end
+
+      # Move cursor left by n columns
+      def left(n = 1)
+        print cursor.backward(n)
+      end
+
+      # Move cursor right by n columns
+      def right(n = 1)
+        print cursor.forward(n)
+      end
+
+      # Move cursor to beginning of current line
+      def line_start
+        print cursor.column(0)
+      end
+
+      # Hide cursor (useful during animations)
+      def hide
+        print cursor.hide
+      end
+
+      # Show cursor (restore after hiding)
+      def show
+        print cursor.show
+      end
+
+      # Clear entire screen and move to top-left
+      def clear_screen
+        print cursor.clear_screen
+        print cursor.move_to(0, 0)
+      end
+
+      # Clear from cursor to end of line
+      def clear_line
+        print cursor.clear_line
+      end
+
+      # Clear from cursor to end of screen
+      def clear_below
+        print cursor.clear_screen_down
+      end
+
+      # Save current cursor position
+      def save_position
+        print cursor.save
+      end
+
+      # Restore previously saved cursor position
+      def restore_position
+        print cursor.restore
+      end
+    end
+  end
+end

data/lib/mumble/error_handler.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Mumble
+  # Centralized error handling for graceful failures
+  module ErrorHandler
+    class << self
+      # Wrap any operation that might fail
+      def safely(fallback: nil, message: nil)
+        yield
+      rescue StandardError => e
+        log_error(e, message)
+        fallback
+      end
+
+      # Handle fatal errors with user-friendly message
+      def fatal(error, context: nil)
+        Cursor.clear_screen
+        Cursor.show
+        Cursor.move_to(1, 1)
+
+        puts Colors.red("╔═══════════════════════════════════════╗")
+        puts Colors.red("║           Oops! Something broke       ║")
+        puts Colors.red("╚═══════════════════════════════════════╝")
+        puts ""
+        puts Colors.yellow("Context: #{context}") if context
+        puts Colors.dim("Error: #{error.message}")
+        puts ""
+        puts Colors.white("Please try restarting the game.")
+        puts Colors.dim("If this keeps happening, try deleting ~/.mumble/")
+        puts ""
+
+        log_error(error, context)
+
+        exit(1)
+      end
+
+      # Log error to file for debugging
+      def log_error(error, context = nil)
+        log_file = File.join(Storage.data_dir, "error.log")
+
+        File.open(log_file, "a") do |f|
+          f.puts "=" * 50
+          f.puts "Time: #{Time.now}"
+          f.puts "Context: #{context}" if context
+          f.puts "Error: #{error.class}: #{error.message}"
+          f.puts "Backtrace:"
+          error.backtrace&.first(10)&.each { |line| f.puts "  #{line}" }
+          f.puts ""
+        end
+      rescue StandardError
+        # If we can't even log, just continue
+        nil
+      end
+
+      # Check if terminal is still valid size
+      def check_terminal_size!
+        return if Screen.valid_size?
+
+        Cursor.clear_screen
+        Cursor.show
+        Cursor.move_to(1, 1)
+
+        puts Colors.yellow("Terminal too small!")
+        puts ""
+        puts "Current size: #{Screen.width}x#{Screen.height}"
+        puts "Required: #{Screen::MIN_WIDTH}x#{Screen::MIN_HEIGHT}"
+        puts ""
+        puts Colors.dim("Please resize your terminal and restart.")
+
+        exit(1)
+      end
+    end
+  end
+end

data/lib/mumble/grid.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "layout"
+require_relative "cursor"
+require_relative "colors"
+
+module Mumble
+  # The 5x6 letter grid display with size variants
+  module Grid
+    # Letter states for coloring
+    STATE_EMPTY = :empty
+    STATE_TYPING = :typing      # Currently being typed (white)
+    STATE_CORRECT = :correct    # Right letter, right position (green)
+    STATE_PRESENT = :present    # Right letter, wrong position (orange)
+    STATE_ABSENT = :absent      # Letter not in word (red)
+
+    # Small grid dimensions (for smaller terminals)
+    SMALL = {
+      cell_width: 5,
+      cell_height: 3,
+      h_gap: 1,
+      v_gap: 1
+    }.freeze
+
+    # Large grid dimensions (for larger terminals)
+    LARGE = {
+      cell_width: 7,
+      cell_height: 5,
+      h_gap: 2,
+      v_gap: 1
+    }.freeze
+
+    class << self
+      # Get dimensions based on terminal size
+      def dimensions
+        case Layout.size_category
+        when :large
+          LARGE
+        else
+          SMALL
+        end
+      end
+
+      # Total width of the entire grid
+      def total_width
+        dims = dimensions
+        (dims[:cell_width] * 5) + (dims[:h_gap] * 4)
+      end
+
+      # Total height of the entire grid
+      def total_height
+        dims = dimensions
+        (dims[:cell_height] * 6) + (dims[:v_gap] * 5)
+      end
+
+      # Draw the entire grid
+      # guesses: array of up to 6 guesses, each guess is array of {letter:, state:}
+      # current_row: which row is active (0-5)
+      # current_input: string being typed in current row
+      def draw(row:, col:, guesses: [], current_row: 0, current_input: "")
+        6.times do |row_index|
+          draw_row(
+            row: row + (row_index * (dimensions[:cell_height] + dimensions[:v_gap])),
+            col: col,
+            letters: guesses[row_index] || [],
+            is_current: row_index == current_row,
+            current_input: row_index == current_row ? current_input : ""
+          )
+        end
+      end
+
+      # Draw a single row of 5 cells
+      def draw_row(row:, col:, letters:, is_current: false, current_input: "")
+        5.times do |col_index|
+          cell_col = col + (col_index * (dimensions[:cell_width] + dimensions[:h_gap]))
+
+          # Determine what to show in this cell
+          if letters[col_index]
+            # Already guessed - show letter with state color
+            letter = letters[col_index][:letter]
+            state = letters[col_index][:state]
+          elsif is_current && current_input[col_index]
+            # Currently typing - show input letter
+            letter = current_input[col_index]
+            state = STATE_TYPING
+          else
+            # Empty cell
+            letter = nil
+            state = STATE_EMPTY
+          end
+
+          draw_cell(row: row, col: cell_col, letter: letter, state: state)
+        end
+      end
+
+      # Draw a single cell with letter
+      def draw_cell(row:, col:, letter:, state:)
+        dims = dimensions
+        color = color_for_state(state)
+
+        if dims[:cell_height] == 3
+          draw_cell_small(row: row, col: col, letter: letter, color: color)
+        else
+          draw_cell_large(row: row, col: col, letter: letter, color: color)
+        end
+      end
+
+      private
+
+      # Small cell (3 lines tall, 5 wide)
+      # ┌───┐
+      # │ A │
+      # └───┘
+      def draw_cell_small(row:, col:, letter:, color:)
+        display_letter = letter&.upcase || " "
+
+        # Top border
+        Cursor.move_to(row, col)
+        print colorize("┌───┐", color)
+
+        # Middle with letter
+        Cursor.move_to(row + 1, col)
+        print colorize("│ #{display_letter} │", color)
+
+        # Bottom border
+        Cursor.move_to(row + 2, col)
+        print colorize("└───┘", color)
+      end
+
+      # Large cell (5 lines tall, 7 wide)
+      # ┌─────┐
+      # │     │
+      # │  A  │
+      # │     │
+      # └─────┘
+      def draw_cell_large(row:, col:, letter:, color:)
+        display_letter = letter&.upcase || " "
+
+        # Top border
+        Cursor.move_to(row, col)
+        print colorize("┌─────┐", color)
+
+        # Empty line
+        Cursor.move_to(row + 1, col)
+        print colorize("│     │", color)
+
+        # Middle with letter
+        Cursor.move_to(row + 2, col)
+        print colorize("│  #{display_letter}  │", color)
+
+        # Empty line
+        Cursor.move_to(row + 3, col)
+        print colorize("│     │", color)
+
+        # Bottom border
+        Cursor.move_to(row + 4, col)
+        print colorize("└─────┘", color)
+      end
+
+      # Get color method name for state
+      def color_for_state(state)
+        case state
+        when STATE_CORRECT
+          :green
+        when STATE_PRESENT
+          :orange
+        when STATE_ABSENT
+          :red
+        when STATE_TYPING
+          :white
+        else
+          :dim
+        end
+      end
+
+      # Apply color to text
+      def colorize(text, color)
+        Colors.send(color, text)
+      end
+    end
+  end
+end