mumble_game 1.0.0

data/lib/mumble/screens/splash.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Mumble
+  module Screens
+    # Animated splash screen with MUMBLE logo
+    class Splash < Base
+      LOGO_SMALL = [
+        "╔╦╗╦ ╦╔╦╗╔╗ ╦  ╔═╗",
+        "║║║║ ║║║║╠╩╗║  ║╣ ",
+        "╩ ╩╚═╝╩ ╩╚═╝╩═╝╚═╝"
+      ].freeze
+
+      LOGO_LARGE = [
+        "███╗   ███╗██╗   ██╗███╗   ███╗██████╗ ██╗     ███████╗",
+        "████╗ ████║██║   ██║████╗ ████║██╔══██╗██║     ██╔════╝",
+        "██╔████╔██║██║   ██║██╔████╔██║██████╔╝██║     █████╗  ",
+        "██║╚██╔╝██║██║   ██║██║╚██╔╝██║██╔══██╗██║     ██╔══╝  ",
+        "██║ ╚═╝ ██║╚██████╔╝██║ ╚═╝ ██║██████╔╝███████╗███████╗",
+        "╚═╝     ╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═════╝ ╚══════╝╚══════╝"
+      ].freeze
+
+      COLORS = %i[red yellow green cyan blue magenta].freeze
+
+      def show
+        setup_screen
+        animate_logo
+        show_tagline
+        show_prompt
+        wait_for_key
+        cleanup_screen
+      end
+
+      private
+
+      def logo
+        medium_screen? ? LOGO_LARGE : LOGO_SMALL
+      end
+
+      def tagline
+        if large_screen?
+          "═══════════════ A Word Guessing Adventure ═══════════════"
+        elsif medium_screen?
+          "══════ A Word Guessing Adventure ══════"
+        else
+          "A Word Guessing Adventure"
+        end
+      end
+
+      def prompt
+        if medium_screen?
+          ">>> Press any key to continue <<<"
+        else
+          "Press any key to continue..."
+        end
+      end
+
+      def logo_start_row
+        center_row_for(logo.length + 8)
+      end
+
+      def logo_start_col
+        Screen.center_col(logo.first.length)
+      end
+
+      def animation_speed
+        case size_category
+        when :large then 0.18
+        when :medium then 0.15
+        else 0.12
+        end
+      end
+
+      def cycle_count
+        case size_category
+        when :large then 6
+        when :medium then 5
+        else 3
+        end
+      end
+
+      # Animate the logo appearing with color cycling
+      def animate_logo
+        # First pass: draw logo line by line with color cycling
+        logo.each_with_index do |line, index|
+          color = COLORS[index % COLORS.length]
+          Cursor.move_to(logo_start_row + index, logo_start_col)
+          print Colors.send(color, line)
+          pause(animation_speed)
+        end
+
+        # Second pass: cycle colors for effect
+        cycle_count.times do
+          COLORS.each do |color|
+            draw_logo_in_color(color)
+            pause(animation_speed)
+          end
+        end
+
+        # Final: settle on cyan
+        draw_logo_in_color(:cyan)
+      end
+
+      def draw_logo_in_color(color)
+        logo.each_with_index do |line, index|
+          Cursor.move_to(logo_start_row + index, logo_start_col)
+          print Colors.send(color, line)
+        end
+      end
+
+      def show_tagline
+        row = logo_start_row + logo.length + 2
+        draw_centered(row, tagline, color: :dim)
+      end
+
+      def show_prompt
+        row = logo_start_row + logo.length + 5
+
+        # Blinking effect for prompt
+        3.times do
+          draw_centered(row, prompt, color: :dim)
+          pause(0.4)
+          draw_centered(row, " " * prompt.length)
+          pause(0.2)
+        end
+
+        draw_centered(row, prompt, color: :dim)
+      end
+    end
+  end
+end

data/lib/mumble/screens/win.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../scorer"
+require_relative "../animations"
+
+module Mumble
+  module Screens
+    # Victory celebration screen with flashing text
+    class Win < Base
+      YOU_WIN_SMALL = [
+        "╦ ╦╔═╗╦ ╦  ╦ ╦╦╔╗╔",
+        "╚╦╝║ ║║ ║  ║║║║║║║",
+        " ╩ ╚═╝╚═╝  ╚╩╝╩╝╚╝"
+      ].freeze
+
+      YOU_WIN_LARGE = [
+        "██╗   ██╗ ██████╗ ██╗   ██╗    ██╗    ██╗██╗███╗   ██╗",
+        "╚██╗ ██╔╝██╔═══██╗██║   ██║    ██║    ██║██║████╗  ██║",
+        " ╚████╔╝ ██║   ██║██║   ██║    ██║ █╗ ██║██║██╔██╗ ██║",
+        "  ╚██╔╝  ██║   ██║██║   ██║    ██║███╗██║██║██║╚██╗██║",
+        "   ██║   ╚██████╔╝╚██████╔╝    ╚███╔███╔╝██║██║ ╚████║",
+        "   ╚═╝    ╚═════╝  ╚═════╝      ╚══╝╚══╝ ╚═╝╚═╝  ╚═══╝"
+      ].freeze
+
+      def initialize(guesses:, time:, level:, word:)
+        super()
+        @guesses = guesses
+        @time = time
+        @level = level
+        @word = word
+        @breakdown = Scorer.breakdown(guesses: guesses, time: time, level: level)
+      end
+
+      def show
+        Cursor.hide
+        draw_screen
+        flash_you_win
+        Input.wait_for_any_key
+        @breakdown[:final_score]
+      end
+
+      private
+
+      def you_win_text
+        Layout.size_category == :large ? YOU_WIN_LARGE : YOU_WIN_SMALL
+      end
+
+      def text_start_row
+        (Screen.height - 30) / 2
+      end
+
+      def text_start_col
+        Screen.center_col(you_win_text.first.length)
+      end
+
+      def draw_screen
+        Cursor.clear_screen
+        draw_you_win_text(:green)
+        draw_content
+      end
+
+      def draw_you_win_text(color)
+        you_win_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_you_win
+        # Flash between green and cyan for celebration
+        6.times do
+          draw_you_win_text(:green)
+          pause(0.2)
+          draw_you_win_text(:cyan)
+          pause(0.15)
+          draw_you_win_text(:yellow)
+          pause(0.15)
+        end
+        # End on solid green
+        draw_you_win_text(:green)
+      end
+
+      def draw_content
+        content_row = text_start_row + you_win_text.length + 2
+
+        # Celebration emoji line
+        draw_centered(content_row, "🎉 🏆 🎉", color: :yellow)
+
+        # Word revealed
+        draw_centered(content_row + 2, "The word was: #{@word}", color: :cyan)
+
+        # Score breakdown
+        draw_score_breakdown(content_row + 5)
+
+        # Rating
+        rating = Scorer.rating(@breakdown[:final_score])
+        rating_row = content_row + 14
+        draw_centered(rating_row, rating, color: :yellow)
+
+        # Continue prompt
+        draw_centered(rating_row + 3, "Press any key to continue...", color: :dim)
+      end
+
+      def draw_score_breakdown(start_row)
+        col = Screen.center_col(30)
+
+        draw_at(start_row, col, "━━━ SCORE BREAKDOWN ━━━", color: :cyan)
+
+        draw_at(start_row + 2, col, "Base Score:", color: :white)
+        draw_at(start_row + 2, col + 20, @breakdown[:base_score].to_s.rjust(6), color: :green)
+
+        draw_at(start_row + 3, col, "Guess Penalty:", color: :white)
+        draw_at(start_row + 3, col + 20, @breakdown[:guess_penalty].to_s.rjust(6), color: :red)
+
+        draw_at(start_row + 4, col, "Time Penalty:", color: :white)
+        draw_at(start_row + 4, col + 20, @breakdown[:time_penalty].to_s.rjust(6), color: :red)
+
+        if @breakdown[:level_multiplier] > 1.0
+          draw_at(start_row + 5, col, "Level #{@level} Bonus:", color: :white)
+          draw_at(start_row + 5, col + 20, "x#{@breakdown[:level_multiplier]}", color: :yellow)
+        end
+
+        draw_at(start_row + 6, col, "━━━━━━━━━━━━━━━━━━━━━━━", color: :cyan)
+        draw_at(start_row + 7, col, "FINAL SCORE:", color: :white)
+
+        # Animate score counting up
+        Animations.count_up(@breakdown[:final_score], duration: 1.5) do |value|
+          Cursor.move_to(start_row + 7, col + 20)
+          print Colors.green(value.to_s.rjust(6))
+        end
+      end
+
+      def pause(seconds)
+        sleep(seconds)
+      end
+    end
+  end
+end

data/lib/mumble/storage.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Mumble
+  # Base storage functionality for persistent data
+  # All data is stored in ~/.mumble/ directory
+  module Storage
+    # Directory where all Mumble data is stored
+    DATA_DIR = File.expand_path("~/.mumble")
+
+    class << self
+      # Ensure the data directory exists with proper permissions
+      def setup
+        return if Dir.exist?(DATA_DIR)
+
+        FileUtils.mkdir_p(DATA_DIR)
+        FileUtils.chmod(0o700, DATA_DIR)
+      end
+
+      # Get full path for a data file
+      def path_for(filename)
+        File.join(DATA_DIR, filename)
+      end
+
+      # Read JSON data from a file
+      # Returns parsed data or nil if file doesn't exist/is invalid
+      def read_json(filename)
+        filepath = path_for(filename)
+        return nil unless File.exist?(filepath)
+
+        data = File.read(filepath)
+        JSON.parse(data, symbolize_names: true)
+      rescue JSON::ParserError
+        # File is corrupted, return nil
+        nil
+      end
+
+      # Write data to a JSON file
+      # Creates file with secure permissions (owner read/write only)
+      def write_json(filename, data)
+        setup
+        filepath = path_for(filename)
+
+        File.write(filepath, JSON.pretty_generate(data))
+        FileUtils.chmod(0o600, filepath)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Delete a data file
+      def delete_file(filename)
+        filepath = path_for(filename)
+        return false unless File.exist?(filepath)
+
+        File.delete(filepath)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Check if a data file exists
+      def file_exists?(filename)
+        File.exist?(path_for(filename))
+      end
+
+      # Delete all Mumble data (for "Delete All Data" feature)
+      def delete_all_data
+        return false unless Dir.exist?(DATA_DIR)
+
+        FileUtils.rm_rf(DATA_DIR)
+        true
+      rescue StandardError
+        false
+      end
+
+      # Get the data directory path (for display to user)
+      def data_directory
+        DATA_DIR
+      end
+    end
+  end
+end

data/lib/mumble/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Mumble
+  VERSION = "1.0.0"
+end

data/lib/mumble/word_cache.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "time"
+require_relative "storage"
+
+module Mumble
+  # Manages cached words fetched from the API
+  module WordCache
+    FILENAME = "word_cache.json"
+    CACHE_DURATION = 24 * 60 * 60 # 24 hours in seconds
+    MIN_WORDS = 20 # Minimum words before we should refresh
+
+    class << self
+      # Load word cache from file
+      def load
+        data = Storage.read_json(FILENAME)
+        return empty_cache if data.nil?
+
+        data
+      end
+
+      # Save word cache to file
+      def save(cache)
+        Storage.write_json(FILENAME, cache)
+      end
+
+      # Get all cached words
+      def words
+        load[:words] || []
+      end
+
+      # Check if cache exists and has words
+      def exists?
+        cache = load
+        !cache[:words].nil? && !cache[:words].empty?
+      end
+
+      # Check if cache is stale (older than 24 hours)
+      def stale?
+        cache = load
+        return true if cache[:fetched_at].nil?
+
+        fetched_time = Time.parse(cache[:fetched_at])
+        Time.now - fetched_time > CACHE_DURATION
+      end
+
+      # Check if cache is running low
+      def low?
+        words.length < MIN_WORDS
+      end
+
+      # Check if we need to fetch new words
+      def needs_refresh?
+        !exists? || stale? || low?
+      end
+
+      # Store new words (replaces existing cache)
+      def store(new_words, source: "api")
+        cache = {
+          words: new_words.map(&:downcase).uniq,
+          fetched_at: Time.now.iso8601,
+          source: source,
+          original_count: new_words.length
+        }
+        save(cache)
+        cache
+      end
+
+      # Add words to existing cache
+      def add(new_words)
+        cache = load
+        existing = cache[:words] || []
+        combined = (existing + new_words.map(&:downcase)).uniq
+
+        cache[:words] = combined
+        cache[:updated_at] = Time.now.iso8601
+        save(cache)
+        cache
+      end
+
+      # Get a random word and remove it from cache
+      def pick_word
+        cache = load
+        return nil if cache[:words].nil? || cache[:words].empty?
+
+        word = cache[:words].sample
+        cache[:words].delete(word)
+        save(cache)
+
+        word.upcase
+      end
+
+      # Get a random word without removing it (for testing)
+      def peek_word
+        cache = load
+        return nil if cache[:words].nil? || cache[:words].empty?
+
+        cache[:words].sample.upcase
+      end
+
+      # Get count of remaining words
+      def count
+        words.length
+      end
+
+      # Clear the cache
+      def clear
+        Storage.delete_file(FILENAME)
+      end
+
+      # Get cache info for debugging
+      def info
+        cache = load
+        {
+          count: cache[:words]&.length || 0,
+          source: cache[:source],
+          fetched_at: cache[:fetched_at],
+          stale: stale?,
+          low: low?
+        }
+      end
+
+      private
+
+      # Return empty cache structure
+      def empty_cache
+        { words: [], fetched_at: nil, source: nil }
+      end
+    end
+  end
+end

data/lib/mumble/word_service.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "openssl"
+require_relative "word_cache"
+require_relative "error_handler"
+
+module Mumble
+  # Handles fetching words from APIs and managing the word supply
+  module WordService
+    # API endpoints
+    DATAMUSE_URL = "https://api.datamuse.com/words"
+    RANDOM_WORD_URL = "https://random-word-api.herokuapp.com/word"
+
+    # Configuration
+    WORD_LENGTH = 5
+    FETCH_COUNT = 500
+    REQUEST_TIMEOUT = 10
+
+    class << self
+      # Get the next word for gameplay
+      # Returns uppercase 5-letter word, or nil if unavailable
+      def next_word
+        ensure_words_available
+        WordCache.pick_word
+      end
+
+      # Ensure we have words available, fetching if needed
+      # Returns true if words are available, false if offline and no cache
+      def ensure_words_available
+        return true unless WordCache.needs_refresh?
+
+        fetch_words
+      end
+
+      # Check if we can provide words (have cache or can fetch)
+      def available?
+        WordCache.exists? || fetch_words
+      end
+
+      # Force a refresh of the word cache
+      def refresh
+        fetch_words
+      end
+
+      # Get status info for debugging/display
+      def status
+        {
+          words_available: WordCache.count,
+          cache_exists: WordCache.exists?,
+          needs_refresh: WordCache.needs_refresh?,
+          cache_info: WordCache.info
+        }
+      end
+
+      private
+
+      # Fetch words from APIs (tries primary, then backup)
+      def fetch_words
+        words = fetch_from_datamuse
+        words = fetch_from_random_word_api if words.empty?
+
+        return false if words.empty?
+
+        WordCache.store(words, source: "api")
+        true
+      end
+
+      # Fetch from Datamuse API (primary)
+      def fetch_from_datamuse
+        uri = URI(DATAMUSE_URL)
+        uri.query = URI.encode_www_form(
+          sp: "?" * WORD_LENGTH,
+          max: FETCH_COUNT
+        )
+
+        response = http_get(uri.to_s)
+        return [] if response.nil?
+
+        words = JSON.parse(response)
+        filter_words(words.map { |w| w["word"] })
+      rescue JSON::ParserError => e
+        ErrorHandler.log_error(e, "Datamuse JSON parse failed")
+        []
+      rescue StandardError => e
+        ErrorHandler.log_error(e, "Datamuse fetch failed")
+        []
+      end
+
+      # Fetch from Random Word API (backup)
+      def fetch_from_random_word_api
+        words = []
+
+        50.times do
+          word_array = fetch_single_random_word
+          words.concat(word_array) if word_array
+        end
+
+        filter_words(words)
+      rescue StandardError => e
+        ErrorHandler.log_error(e, "Random Word API fetch failed")
+        []
+      end
+
+      # Fetch a single word from Random Word API
+      # Returns array of words or nil on failure
+      def fetch_single_random_word
+        uri = "#{RANDOM_WORD_URL}?length=#{WORD_LENGTH}"
+        response = http_get(uri)
+        return nil if response.nil?
+
+        word_array = JSON.parse(response)
+        word_array.is_a?(Array) ? word_array : nil
+      rescue StandardError
+        nil
+      end
+
+      # Make HTTP request with timeout and error handling
+      def http_get(url)
+        uri = URI.parse(url)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = REQUEST_TIMEOUT
+        http.read_timeout = REQUEST_TIMEOUT
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        response = http.request(request)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        response.body
+      rescue StandardError => e
+        handle_http_error(e, url)
+      end
+
+      # Handle HTTP errors based on type
+      def handle_http_error(error, url)
+        case error
+        when Net::OpenTimeout, Net::ReadTimeout, SocketError, Errno::ECONNREFUSED, Errno::ENETUNREACH
+          # Network unavailable or timeout - expected, no logging needed
+          nil
+        when OpenSSL::SSL::SSLError
+          # SSL issues - try without verification as fallback
+          retry_without_ssl_verify(url)
+        else
+          # Unexpected error - log it
+          ErrorHandler.log_error(error, "HTTP request failed: #{url}")
+          nil
+        end
+      end
+
+      # Retry HTTP request without SSL verification (fallback for cert issues)
+      def retry_without_ssl_verify(url)
+        uri = URI.parse(url)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = REQUEST_TIMEOUT
+        http.read_timeout = REQUEST_TIMEOUT
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        response = http.request(request)
+
+        response.is_a?(Net::HTTPSuccess) ? response.body : nil
+      rescue StandardError
+        nil
+      end
+
+      # Filter words to ensure they're valid for the game
+      def filter_words(words)
+        words
+          .map(&:downcase)
+          .select { |w| valid_word?(w) }
+          .uniq
+      end
+
+      # Check if a word is valid for the game
+      def valid_word?(word)
+        return false unless word.is_a?(String)
+        return false unless word.length == WORD_LENGTH
+        return false unless word.match?(/\A[a-z]+\z/)
+
+        true
+      end
+    end
+  end
+end