mumble_game 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d7549dec66263103042334d5385c1341fb7233ea59c921ed040971391db6a48
+  data.tar.gz: 017b9cc6b4951ed33519a76db06e549bc4abc30b08554e0ddc672e62047aaa46
+SHA512:
+  metadata.gz: 68c0e669ce3d2c2d22d764c2ecd5ad85b4dfeed8a8db3f108e24ccfd5a15d8b3c57f7f2c3d1af2b175e645ffb85b1b6b815ecbed0eb5c8f9f300fbf5576c66ff
+  data.tar.gz: 52648f20b2dbdc082a00cb0e1b237e98bd255302b594c95c4fa17d18d69a48006fa6e459535de94a8da1f2c2df760fed3000eb298caf0b9bdaa8e1129e9c4d94

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2026-01-23
+
+### Added
+
+- Complete Wordle + Hangman gameplay
+- Terminal UI with colors and animations
+- Word fetching from Datamuse API with caching
+- High scores leaderboard (top 10)
+- Player profiles with statistics
+- Win/Lose screens with score breakdown
+- Level progression system
+- Responsive design for small/large terminals
+- Graceful error handling
+- Ctrl+C clean exit
+
+### Features
+
+- 5-letter word guessing
+- Color-coded letter feedback (green/orange/red)
+- Hangman visualization (7 stages)
+- Score calculation with time/guess penalties
+- Level multiplier bonuses
+- Current/best streak tracking
+- Animated letter reveals
+- Loading spinner for API calls
+- Flashing win/lose screens
+
+## [0.1.0] - 2026-01-20
+
+### Added
+
+- Initial project structure
+- Gem skeleton with `mumble` executable
+- RSpec test configuration
+- RuboCop linting configuration
+- MIT License

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Hady Mohamed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,130 @@
+# 🎮 Mumble
+
+A terminal-based word guessing game combining Wordle and Hangman mechanics, built in Ruby.
+
+![Mumble Game](screenshots/gameplay.png)
+
+## Features
+
+- 🎯 **Wordle-style gameplay** - Guess the 5-letter word with color-coded feedback
+- ☠️ **Hangman integration** - Wrong guesses build the hangman
+- 🏆 **High scores** - Track your best performances
+- 📊 **Statistics** - Games played, win rate, streaks
+- 🎨 **Beautiful terminal UI** - Colors, animations, ASCII art
+- 💾 **Persistent data** - Your progress is saved locally
+- 🌐 **Online word fetching** - Fresh words from Datamuse API
+- 📱 **Responsive design** - Adapts to small and large terminals
+
+## Installation
+
+```bash
+gem install mumble_game
+```
+
+Or add to your Gemfile:
+
+```ruby
+gem "mumble_game"
+```
+
+## Usage
+
+Simply run:
+
+```bash
+mumble
+```
+
+### Controls
+
+| Key | Action |
+|-----|--------|
+| A-Z | Type letters |
+| Backspace | Delete letter |
+| Enter | Submit guess |
+| ↑↓ | Navigate menus |
+| 1-5 | Quick menu select |
+| Ctrl+C | Exit game |
+
+### Color Guide
+
+| Color | Meaning |
+|-------|---------|
+| 🟩 Green | Correct letter, correct position |
+| 🟧 Orange | Correct letter, wrong position |
+| 🟥 Red | Letter not in word |
+
+## Requirements
+
+- Ruby 3.0+
+- Terminal with 80x24 minimum size
+- Internet connection (for word fetching, optional)
+
+## Screenshots
+
+### Main Menu
+
+![Main Menu](screenshots/menu.png)
+
+### Gameplay
+
+![Gameplay](screenshots/gameplay.png)
+
+### Win Screen
+
+![Win](screenshots/win.png)
+
+### Lose Screen
+
+![Lose](screenshots/lose.png)
+
+### High Scores
+
+![High Scores](screenshots/high_scores.png)
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/yourusername/mumble_game.git
+cd mumble_game
+
+# Install dependencies
+bundle install
+
+# Run the game
+bundle exec rake play
+
+# Run tests
+bundle exec rake spec
+
+# Run linter
+bundle exec rubocop
+```
+
+## Data Storage
+
+Mumble stores data in `~/.mumble/`:
+
+- `config.json` - Player profile and settings
+- `high_scores.json` - Leaderboard
+- `word_cache.json` - Cached words for offline play
+- `error.log` - Error logs for debugging
+
+To reset all data:
+
+```bash
+rm -rf ~/.mumble
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub. See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+This gem is available as open source under the [MIT License](LICENSE).
+
+## Author
+
+Built with ❤️ by Hady Mohamed

data/bin/mumble

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "mumble"
+
+Mumble.start

data/lib/mumble/animations.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Mumble
+  # Reusable animation helpers for terminal effects
+  module Animations
+    class << self
+      # Animate a number counting up from 0 to target
+      def count_up(target, duration: 1.0)
+        return yield(target) if target <= 0
+
+        steps = [target, 20].min # Max 20 steps
+        delay = duration / steps
+        increment = target / steps.to_f
+
+        current = 0.0
+        steps.times do
+          current += increment
+          yield(current.round)
+          sleep(delay)
+        end
+
+        # Ensure we end on exact target
+        yield(target)
+      end
+
+      # Display a loading spinner with message
+      def spinner(message: "Loading", duration: nil, &block)
+        frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+        if block_given?
+          # Run block in thread while showing spinner
+          result = nil
+          done = false
+
+          thread = Thread.new do
+            result = block.call
+            done = true
+          end
+
+          frame_index = 0
+          until done
+            Cursor.move_to(Screen.center_row, Screen.center_col(message.length + 4))
+            print Colors.cyan("#{frames[frame_index]} #{message}...")
+            frame_index = (frame_index + 1) % frames.length
+            sleep(0.1)
+          end
+
+          thread.join
+
+          # Clear spinner line
+          Cursor.move_to(Screen.center_row, Screen.center_col(message.length + 4))
+          print " " * (message.length + 10)
+
+          result
+        else
+          # Just show spinner for duration
+          frames_to_show = ((duration || 1.0) / 0.1).round
+
+          frames_to_show.times do |i|
+            Cursor.move_to(Screen.center_row, Screen.center_col(message.length + 4))
+            print Colors.cyan("#{frames[i % frames.length]} #{message}...")
+            sleep(0.1)
+          end
+        end
+      end
+
+      # Flash text between two colors
+      def flash(row:, col:, text:, color1:, color2:, times: 3, speed: 0.2)
+        times.times do
+          Cursor.move_to(row, col)
+          print Colors.send(color1, text)
+          sleep(speed)
+          Cursor.move_to(row, col)
+          print Colors.send(color2, text)
+          sleep(speed)
+        end
+        # End on first color
+        Cursor.move_to(row, col)
+        print Colors.send(color1, text)
+      end
+
+      # Reveal text character by character
+      def typewriter(row:, col:, text:, color: :white, speed: 0.05)
+        text.each_char.with_index do |char, i|
+          Cursor.move_to(row, col + i)
+          print Colors.send(color, char)
+          sleep(speed)
+        end
+      end
+
+      # Fade transition (clear screen with brief pause)
+      def fade_transition(duration: 0.3)
+        sleep(duration / 2)
+        Cursor.clear_screen
+        sleep(duration / 2)
+      end
+
+      # Celebrate with rainbow color cycling on text
+      def rainbow_text(row:, text:, cycles: 2, speed: 0.1)
+        colors = %i[red yellow green cyan blue magenta]
+        col = Screen.center_col(text.length)
+
+        (cycles * colors.length).times do |i|
+          color = colors[i % colors.length]
+          Cursor.move_to(row, col)
+          print Colors.send(color, text)
+          sleep(speed)
+        end
+      end
+    end
+  end
+end

data/lib/mumble/box.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "cursor"
+require_relative "colors"
+
+module Mumble
+  # Draws bordered boxes and UI containers in the terminal
+  module Box
+    # Box drawing characters (Unicode)
+    CHARS = {
+      top_left: "╔",
+      top_right: "╗",
+      bottom_left: "╚",
+      bottom_right: "╝",
+      horizontal: "═",
+      vertical: "║",
+      # Single line variants for inner boxes
+      single_top_left: "┌",
+      single_top_right: "┐",
+      single_bottom_left: "└",
+      single_bottom_right: "┘",
+      single_horizontal: "─",
+      single_vertical: "│"
+    }.freeze
+
+    class << self
+      # Draw a double-line box at specified position
+      # row, col = top-left corner position
+      # width, height = outer dimensions including border
+      def draw(row:, col:, width:, height:, color: nil)
+        top = CHARS[:top_left] + (CHARS[:horizontal] * (width - 2)) + CHARS[:top_right]
+        bottom = CHARS[:bottom_left] + (CHARS[:horizontal] * (width - 2)) + CHARS[:bottom_right]
+        middle = CHARS[:vertical] + (" " * (width - 2)) + CHARS[:vertical]
+
+        # Apply color if specified
+        top = apply_color(top, color)
+        bottom = apply_color(bottom, color)
+        middle = apply_color(middle, color)
+
+        # Draw top border
+        Cursor.move_to(row, col)
+        print top
+
+        # Draw middle rows
+        (height - 2).times do |i|
+          Cursor.move_to(row + 1 + i, col)
+          print middle
+        end
+
+        # Draw bottom border
+        Cursor.move_to(row + height - 1, col)
+        print bottom
+      end
+
+      # Draw a single-line box (for letter cells)
+      def draw_single(row:, col:, width:, height:, color: nil)
+        top = CHARS[:single_top_left] + (CHARS[:single_horizontal] * (width - 2)) + CHARS[:single_top_right]
+        bottom = CHARS[:single_bottom_left] + (CHARS[:single_horizontal] * (width - 2)) + CHARS[:single_bottom_right]
+        middle = CHARS[:single_vertical] + (" " * (width - 2)) + CHARS[:single_vertical]
+
+        top = apply_color(top, color)
+        bottom = apply_color(bottom, color)
+        middle = apply_color(middle, color)
+
+        Cursor.move_to(row, col)
+        print top
+
+        (height - 2).times do |i|
+          Cursor.move_to(row + 1 + i, col)
+          print middle
+        end
+
+        Cursor.move_to(row + height - 1, col)
+        print bottom
+      end
+
+      # Draw a box with a centered title on the top border
+      def draw_with_title(row:, col:, width:, height:, title:, color: nil)
+        # Calculate title position
+        title_with_padding = " #{title} "
+        title_start = (width - title_with_padding.length) / 2
+
+        # Build top border with title
+        left_border = CHARS[:horizontal] * (title_start - 1)
+        right_border = CHARS[:horizontal] * (width - title_start - title_with_padding.length - 1)
+        top = CHARS[:top_left] + left_border + title_with_padding + right_border + CHARS[:top_right]
+
+        bottom = CHARS[:bottom_left] + (CHARS[:horizontal] * (width - 2)) + CHARS[:bottom_right]
+        middle = CHARS[:vertical] + (" " * (width - 2)) + CHARS[:vertical]
+
+        top = apply_color(top, color)
+        bottom = apply_color(bottom, color)
+        middle = apply_color(middle, color)
+
+        Cursor.move_to(row, col)
+        print top
+
+        (height - 2).times do |i|
+          Cursor.move_to(row + 1 + i, col)
+          print middle
+        end
+
+        Cursor.move_to(row + height - 1, col)
+        print bottom
+      end
+
+      # Write text inside a box at a specific row offset from top
+      # text_row is relative to box interior (1 = first line inside box)
+      def write_inside(box_row:, box_col:, box_width:, text_row:, text:, centered: false, color: nil)
+        text_col = if centered
+                     box_col + 1 + ((box_width - 2 - text.length) / 2)
+                   else
+                     box_col + 2
+                   end
+
+        Cursor.move_to(box_row + text_row, text_col)
+        print color ? apply_color(text, color) : text
+      end
+
+      private
+
+      # Apply color using the Colors module
+      def apply_color(text, color)
+        return text unless color
+
+        case color
+        when :green then Colors.green(text)
+        when :red then Colors.red(text)
+        when :orange then Colors.orange(text)
+        when :cyan then Colors.cyan(text)
+        when :yellow then Colors.yellow(text)
+        when :dim then Colors.dim(text)
+        when :bold then Colors.bold(text)
+        else text
+        end
+      end
+    end
+  end
+end

data/lib/mumble/colors.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Mumble
+  # Provides color helpers for terminal output
+  # Uses Pastel gem for cross-platform ANSI color support
+  module Colors
+    class << self
+      # Memoized Pastel instance for performance
+      def pastel
+        @pastel ||= Pastel.new
+      end
+
+      # Correct letter, correct position
+      def green(text)
+        pastel.green(text)
+      end
+
+      # Correct letter, wrong position
+      def orange(text)
+        "\e[38;5;208m#{text}\e[0m"
+      end
+
+      # Letter not in word
+      def red(text)
+        pastel.red(text)
+      end
+
+      # UI accents, titles, highlights
+      def cyan(text)
+        pastel.cyan(text)
+      end
+
+      # Dimmed/muted text for hints and secondary info
+      def dim(text)
+        pastel.dim(text)
+      end
+
+      # Bold text for emphasis
+      def bold(text)
+        pastel.bold(text)
+      end
+
+      # Yellow for warnings and streak indicators
+      def yellow(text)
+        pastel.yellow(text)
+      end
+
+      # Magenta for special highlights
+      def magenta(text)
+        pastel.magenta(text)
+      end
+
+      # White for default bright text
+      def white(text)
+        pastel.white(text)
+      end
+
+      # Blue for accents
+      def blue(text)
+        pastel.blue(text)
+      end
+
+      # Combine styles - e.g., bold_green("WIN!")
+      def bold_green(text)
+        pastel.bold.green(text)
+      end
+
+      def bold_red(text)
+        pastel.bold.red(text)
+      end
+
+      def bold_cyan(text)
+        pastel.bold.cyan(text)
+      end
+
+      def bold_yellow(text)
+        pastel.bold.yellow(text)
+      end
+    end
+  end
+end