git_game_show 0.2.1 → 0.2.2

data/lib/git_game_show/message_type.rb

@@ -0,0 +1,18 @@
+module GitGameShow
+  # Message types for client-server communication
+  module MessageType
+    JOIN_REQUEST = 'join_request'
+    JOIN_RESPONSE = 'join_response'
+    PLAYER_JOINED = 'player_joined'
+    PLAYER_LEFT = 'player_left'
+    GAME_START = 'game_start'
+    GAME_END = 'game_end'
+    GAME_RESET = 'game_reset'
+    QUESTION = 'question'
+    ANSWER = 'answer'
+    ANSWER_FEEDBACK = 'answer_feedback'
+    ROUND_RESULT = 'round_result'
+    SCOREBOARD = 'scoreboard'
+    CHAT = 'chat'
+  end
+end

data/lib/git_game_show/network/message_handler.rb

@@ -0,0 +1,241 @@
+module GitGameShow
+  # Handles WebSocket messages
+  class MessageHandler
+    def initialize(player_manager, game_state, renderer, server_handler)
+      @player_manager = player_manager
+      @game_state = game_state
+      @renderer = renderer
+      @server_handler = server_handler
+      @password = nil # Will be set through setter
+    end
+
+    def set_password(password)
+      @password = password
+    end
+
+    def handle_message(ws, msg)
+      begin
+        data = JSON.parse(msg)
+        case data['type']
+        when MessageType::JOIN_REQUEST
+          handle_join_request(ws, data)
+        when MessageType::ANSWER
+          handle_answer(data)
+        when MessageType::CHAT
+          @server_handler.broadcast_message(data)
+        else
+          @renderer.log_message("Unknown message type: #{data['type']}", :red)
+        end
+      rescue JSON::ParserError => e
+        @renderer.log_message("Invalid message format: #{e.message}", :red)
+      rescue => e
+        @renderer.log_message("Error processing message: #{e.message}", :red)
+      end
+    end
+
+    def handle_player_disconnect(ws)
+      # Find the player who disconnected
+      player_name = @player_manager.find_player_by_ws(ws)
+      return unless player_name
+
+      # Remove the player
+      @player_manager.remove_player(player_name)
+
+      # Update the sidebar to reflect the player leaving
+      @server_handler.instance_variable_get(:@sidebar)&.update_player_list(@player_manager.player_names, @player_manager.scores)
+
+      # Log message for player leaving
+      @renderer.log_message("🔴 #{player_name} has left the game", :yellow)
+
+      # Notify other players
+      @server_handler.broadcast_message({
+        type: 'player_left',
+        name: player_name,
+        players: @player_manager.player_names
+      })
+    end
+
+    def broadcast(json_message, exclude = nil)
+      @player_manager.players.each do |player_name, ws|
+        # Skip excluded player if specified
+        next if exclude && player_name == exclude
+
+        # Skip nil websockets
+        next unless ws
+
+        # Send with error handling for each individual player
+        begin
+          ws.send(json_message)
+        rescue => e
+          @renderer.log_message("Error sending to #{player_name}: #{e.message}", :yellow)
+        end
+      end
+    end
+
+    private
+
+    def handle_join_request(ws, data)
+      player_name = data['name']
+      sent_password = data['password']
+
+      response = {
+        type: MessageType::JOIN_RESPONSE
+      }
+
+      # Check if game is already in progress
+      if @game_state.playing?
+        response.merge!(success: false, message: "Game is already in progress")
+      # Validate password
+      elsif sent_password != @password
+        response.merge!(success: false, message: "Incorrect password")
+      # Check for duplicate names
+      elsif @player_manager.player_exists?(player_name)
+        response.merge!(success: false, message: "Player name already taken")
+      else
+        # Add player to the game
+        @player_manager.add_player(player_name, ws)
+
+        # Update the sidebar to show the new player
+        @server_handler.instance_variable_get(:@sidebar)&.update_player_list(@player_manager.player_names, @player_manager.scores)
+
+        # Include current player list in the response
+        response.merge!(
+          success: true,
+          message: "Successfully joined the game",
+          players: @player_manager.player_names
+        )
+
+        # Notify all existing players about the new player
+        @server_handler.broadcast_message({
+          type: 'player_joined',
+          name: player_name,
+          players: @player_manager.player_names
+        }, exclude: player_name)
+
+        # Log message for player joining
+        @renderer.log_message("🟢 #{player_name} has joined the game", :green)
+      end
+
+      ws.send(response.to_json)
+    end
+
+    def handle_answer(data)
+      return unless @game_state.playing?
+
+      player_name = data['name']
+      answer = data['answer']
+      question_id = data['question_id']
+
+      # Make sure the answer is for the current question
+      return unless question_id == @game_state.current_question_id
+
+      # Don't allow duplicate answers
+      return if @game_state.player_answers.dig(player_name, :answered)
+
+      # Calculate time taken to answer
+      time_taken = Time.now - @game_state.question_start_time
+
+      # Get current question
+      current_question = @game_state.current_question
+
+      # Handle nil answer (timeout) differently
+      points = 0
+
+      if answer.nil?
+        # For timeouts, set a special "TIMEOUT" answer with 0 points
+        @game_state.record_player_answer(player_name, "TIMEOUT", time_taken, false, 0)
+
+        # Send timeout feedback to the player
+        feedback = {
+          type: MessageType::ANSWER_FEEDBACK,
+          answer: "TIMEOUT",
+          correct: false,
+          correct_answer: current_question[:correct_answer],
+          points: points
+        }
+        @player_manager.get_ws(player_name)&.send(feedback.to_json)
+
+        # Log the timeout
+        truncated_name = player_name.length > 15 ? "#{player_name[0...12]}..." : player_name
+        @renderer.log_message("#{truncated_name} timed out after #{time_taken.round(2)}s ⏰", :yellow)
+      else
+        # Regular answer processing
+        # For ordering quizzes, we'll calculate points in evaluate_answers
+        if current_question[:question_type] == 'ordering'
+          # Just store the answer and time, points will be calculated in evaluate_answers
+          correct = false # Will be properly set during evaluation
+
+          # Get the mini-game to evaluate this answer for points
+          mini_game = @game_state.current_mini_game
+          points = mini_game.evaluate_answers(
+            current_question,
+            {player_name => {answer: answer, time_taken: time_taken}}
+          ).values.first[:points]
+        else
+          # For regular quizzes, calculate points immediately
+          correct = answer == current_question[:correct_answer]
+          points = 0
+
+          if correct
+            points = 10 # Base points for correct answer
+
+            # Bonus points for fast answers
+            if time_taken < 5
+              points += 5
+            elsif time_taken < 10
+              points += 3
+            end
+          end
+        end
+
+        # Store the answer
+        @game_state.record_player_answer(player_name, answer, time_taken, correct, points)
+
+        # Send immediate feedback to this player only
+        send_answer_feedback(player_name, answer, correct, current_question, points)
+
+        # Log this answer - ensure the name is not too long
+        truncated_name = player_name.length > 15 ? "#{player_name[0...12]}..." : player_name
+        if current_question[:question_type] == 'ordering'
+          @renderer.log_message("#{truncated_name} submitted ordering in #{time_taken.round(2)}s ⏱️", :cyan)
+        else
+          @renderer.log_message("#{truncated_name} answered in #{time_taken.round(2)}s: #{correct ? "Correct ✓" : "Wrong ✗"}", correct ? :green : :red)
+        end
+      end
+
+      # Check if all players have answered
+      check_all_answered
+    end
+
+    def send_answer_feedback(player_name, answer, correct, question, points=0)
+      # Send feedback only to the player who answered
+      ws = @player_manager.get_ws(player_name)
+      return unless ws
+
+      feedback = {
+        type: MessageType::ANSWER_FEEDBACK,
+        answer: answer,
+        correct: correct,
+        correct_answer: question[:correct_answer],
+        points: points # Include points in the feedback
+      }
+
+      # For ordering quizzes, we can't determine correctness immediately
+      if question[:question_type] == 'ordering'
+        feedback[:correct] = nil # nil means "scoring in progress"
+        # Keep the points value that was calculated earlier
+        feedback[:message] = "Ordering submitted. Points calculated based on your ordering."
+      end
+
+      ws.send(feedback.to_json)
+    end
+
+    def check_all_answered
+      # If all players have answered, log it but WAIT for the full timeout
+      if @game_state.player_answers.keys.size == @player_manager.player_count
+        timeout_sec = GitGameShow::DEFAULT_CONFIG[:question_timeout]
+        @renderer.log_message("All players have answered - waiting for timeout (#{timeout_sec}s)", :cyan)
+      end
+    end
+  end
+end

data/lib/git_game_show/network/server.rb

@@ -0,0 +1,52 @@
+module GitGameShow
+  # WebSocket server management
+  class Server
+    attr_reader :port
+    
+    def initialize(port, message_handler)
+      @port = port
+      @message_handler = message_handler
+    end
+
+    def start
+      WebSocket::EventMachine::Server.start(host: '0.0.0.0', port: @port) do |ws|
+        ws.onopen do
+          # Connection is logged when a player successfully joins
+        end
+
+        ws.onmessage do |msg|
+          @message_handler.handle_message(ws, msg)
+        end
+
+        ws.onclose do
+          @message_handler.handle_player_disconnect(ws)
+        end
+      end
+    end
+
+    def broadcast_message(message, exclude: nil)
+      return if message.nil?
+
+      begin
+        # Convert message to JSON safely
+        json_message = nil
+        begin
+          json_message = message.to_json
+        rescue => e
+          # Try to simplify the message to make it JSON-compatible
+          simplified_message = {
+            type: message[:type] || "unknown",
+            message: "Error processing full message"
+          }
+          json_message = simplified_message.to_json
+        end
+
+        return unless json_message
+
+        @message_handler.broadcast(json_message, exclude)
+      rescue => e
+        # Silently fail for now
+      end
+    end
+  end
+end

data/lib/git_game_show/player_client.rb

@@ -147,15 +147,15 @@ module GitGameShow
       # Display instructions and welcome information
       puts "\n"
       puts "  Welcome to Git Game Show!".colorize(:yellow)
-      puts "  Test your knowledge about Git and your team's commits through fun mini-games.".colorize(:light_white)
+      puts "  Test your knowledge about Git and your team's commits through fun mini-games.".colorize(:light_black)
       puts "\n"
       puts "  🔹 Instructions:".colorize(:light_blue)
-      puts "    • The game consists of multiple rounds with different question types".colorize(:light_white)
-      puts "    • Each round has a theme based on Git commit history".colorize(:light_white)
-      puts "    • Answer questions as quickly as possible for maximum points".colorize(:light_white)
-      puts "    • The player with the most points at the end wins!".colorize(:light_white)
+      puts "    • The game consists of multiple rounds with different question types".colorize(:light_black)
+      puts "    • Each round has a theme based on Git commit history".colorize(:light_black)
+      puts "    • Answer questions as quickly as possible for maximum points".colorize(:light_black)
+      puts "    • The player with the most points at the end wins!".colorize(:light_black)
       puts "\n"
-      puts "  🔹 Status: Waiting for the host to start the game...".colorize(:light_yellow)
+      puts "  🔹 Status: Waiting for the host to start the game...".colorize(:yellow)
       puts "\n"
 
       # Draw player section in a box
@@ -207,7 +207,7 @@ module GitGameShow
 
       puts "\n"
       puts "  When the game starts, you'll see questions appear automatically.".colorize(:light_black)
-      puts "  Get ready to test your Git knowledge!".colorize(:light_yellow)
+      puts "  Get ready to test your Git knowledge!".colorize(:yellow)
       puts "\n"
     end
 
@@ -508,7 +508,7 @@ module GitGameShow
       color = if seconds <= 5
                 :red
               elsif seconds <= 10
-                :light_yellow
+                :yellow
               else
                 :green
               end
@@ -860,7 +860,7 @@ module GitGameShow
         # Show bonus points details if applicable
         if data['points'] > 10 # More than base points
           bonus = data['points'] - 10
-          puts "   🎉 SPEED BONUS: +#{bonus} points for fast answer!".colorize(:light_yellow)
+          puts "   🎉 SPEED BONUS: +#{bonus} points for fast answer!".colorize(:yellow)
         end
       else
         if data['correct_answer'].is_a?(Array)
@@ -993,7 +993,7 @@ module GitGameShow
           output = "   #{rank_display} #{player_str.ljust(20)} #{score} points"
 
           if player == name
-            puts output.colorize(:light_yellow)
+            puts output.colorize(:yellow)
           else
             puts output.colorize(:light_blue)
           end
@@ -1038,7 +1038,7 @@ module GitGameShow
         case position
         when 1
           position_str = "🥇 #{position_str}"
-          puts "   #{position_str.ljust(5)} #{player_str.ljust(25)} #{score_str}".colorize(:light_yellow)
+          puts "   #{position_str.ljust(5)} #{player_str.ljust(25)} #{score_str}".colorize(:yellow)
         when 2
           position_str = "🥈 #{position_str}"
           puts "   #{position_str.ljust(5)} #{player_str.ljust(25)} #{score_str}".colorize(:light_blue)
@@ -1095,9 +1095,9 @@ module GitGameShow
 
       winner_is_you = winner == name
       if winner_is_you
-        puts "🎉 Congratulations! You won! 🎉".center(@game_width).colorize(:light_yellow)
+        puts "🎉 Congratulations! You won! 🎉".center(@game_width).colorize(:yellow)
       else
-        puts "Winner: #{winner}! 🏆".center(@game_width).colorize(:light_yellow)
+        puts "Winner: #{winner}! 🏆".center(@game_width).colorize(:yellow)
       end
 
       puts ""
@@ -1126,7 +1126,7 @@ module GitGameShow
         when 1
           position_str = "🥇 #{position_str}"
           left_string = (position_str.rjust(5) + ' ' + player_str).ljust(scores_width - score_str.length)
-          puts "#{left_string}#{score_str}".center(@game_width).colorize(:light_yellow)
+          puts "#{left_string}#{score_str}".center(@game_width).colorize(:yellow)
         when 2
           position_str = "🥈 #{position_str}"
           left_string = (position_str.rjust(5) + ' ' + player_str).ljust(scores_width - score_str.length)

data/lib/git_game_show/server_handler.rb

@@ -0,0 +1,299 @@
+module GitGameShow
+  # Coordinates the various components of the game server
+  class ServerHandler
+    attr_reader :game_state, :player_manager, :question_manager
+
+    def initialize(port:, password:, rounds:, repo:)
+      @port = port
+      @password = password
+      @rounds = rounds
+      @repo = repo
+
+      # Initialize core components
+      @game_state = GameState.new(rounds)
+      @player_manager = PlayerManager.new
+      @mini_game_loader = MiniGameLoader.new
+
+      # Initialize UI components
+      @renderer = Renderer.new
+      @sidebar = Sidebar.new(@renderer)
+      @console = Console.new(self, @renderer)
+
+      # Initialize network components - passing self allows circular reference
+      @message_handler = MessageHandler.new(@player_manager, @game_state, @renderer, self)
+      @message_handler.set_password(password)
+      @server = Server.new(port, @message_handler)
+
+      # Finally initialize the question manager
+      @question_manager = QuestionManager.new(@game_state, @player_manager)
+    end
+
+    def start_with_ui(join_link = nil)
+      # Store join link as instance variable so it's accessible throughout the class
+      @join_link = join_link
+
+      # Setup UI
+      @renderer.setup
+      @renderer.draw_welcome_banner
+      @renderer.draw_join_link(@join_link) if @join_link
+      @sidebar.draw_header
+      @sidebar.update_player_list(@player_manager.player_names, @player_manager.scores)
+      @renderer.draw_command_prompt
+
+      # Start event machine
+      EM.run do
+        # Start the server
+        @server.start
+        # Setup console commands
+        @console.setup_command_handler
+      end
+    end
+
+    # Game lifecycle methods
+    def handle_start_command
+      if @player_manager.player_count < 1
+        @renderer.log_message("Need at least one player to start", :red)
+        return
+      end
+
+      # If players are in an ended state, reset them first
+      if @game_state.ended?
+        @renderer.log_message("Resetting players from previous game...", :light_black)
+        broadcast_message({
+          type: MessageType::GAME_RESET,
+          message: "Get ready! The host is starting a new game..."
+        })
+        # Give players a moment to see the reset message
+        sleep(1)
+      end
+
+      # Start the game
+      if @game_state.start_game
+        broadcast_message({
+          type: MessageType::GAME_START,
+          rounds: @rounds,
+          players: @player_manager.player_names
+        })
+
+        @renderer.log_message("Game started with #{@player_manager.player_count} players", :green)
+        start_next_round
+      end
+    end
+
+    def handle_end_command
+      if @game_state.playing?
+        @renderer.log_message("Ending game early...", :yellow)
+        end_game
+      elsif @game_state.ended?
+        @renderer.log_message("Game already ended. Type 'start' to begin a new game.", :yellow)
+      else
+        @renderer.log_message("No game in progress to end", :yellow)
+      end
+    end
+
+    def handle_reset_command
+      if @game_state.ended?
+        @renderer.log_message("Manually resetting all players to waiting room state...", :yellow)
+
+        # Send a game reset message to all players
+        broadcast_message({
+          type: MessageType::GAME_RESET,
+          message: "Game has been reset by the host. Waiting for a new game to start."
+        })
+
+        # Update game state
+        @game_state.reset_game
+      else
+        @renderer.log_message("Can only reset after a game has ended", :yellow)
+      end
+    end
+
+    def start_next_round
+      @game_state.start_next_round(@mini_game_loader.select_next_mini_game)
+
+      # Check if we've completed all rounds
+      if @game_state.current_round > @rounds
+        @renderer.log_message("All rounds completed! Showing final scores...", :green)
+        EM.next_tick { end_game } # Use next_tick to ensure it runs after current operations
+        return
+      end
+
+      # Announce new round
+      broadcast_message({
+        type: 'round_start',
+        round: @game_state.current_round,
+        total_rounds: @rounds,
+        mini_game: @game_state.current_mini_game.class.name,
+        description: @game_state.current_mini_game.class.description,
+        example: @game_state.current_mini_game.class.example
+      })
+
+      # Generate questions for this round
+      @question_manager.generate_questions(@repo)
+
+      @renderer.log_message("Starting round #{@game_state.current_round}: #{@game_state.current_mini_game.class.name}", :cyan)
+
+      # Start the first question after a short delay
+      EM.add_timer(3) do
+        ask_next_question
+      end
+    end
+
+    def ask_next_question
+      return if @game_state.current_question_index >= @game_state.round_questions.size
+
+      # Log information for debugging
+      @renderer.log_message("Preparing question #{@game_state.current_question_index + 1} of #{@game_state.round_questions.size}", :cyan)
+
+      # Prepare the question
+      @game_state.prepare_next_question
+      current_question = @game_state.current_question
+
+      # Get the appropriate timeout value
+      timeout = @question_manager.question_timeout
+
+      # Prepare question data
+      begin
+        question_data = {
+          type: MessageType::QUESTION,
+          question_id: @game_state.current_question_id.to_s,
+          question: current_question[:question].to_s,
+          options: current_question[:options] || [],
+          timeout: timeout,
+          round: @game_state.current_round.to_i,
+          question_number: (@game_state.current_question_index + 1).to_i,
+          total_questions: @game_state.round_questions.size.to_i
+        }
+
+        # Add additional question data safely
+        # Add question_type if it's a special question type (like ordering)
+        if current_question && current_question[:question_type]
+          question_data[:question_type] = current_question[:question_type].to_s
+        end
+
+        # Add commit info if available (for AuthorQuiz)
+        if current_question && current_question[:commit_info]
+          # Make a safe copy to avoid potential issues with the original object
+          if current_question[:commit_info].is_a?(Hash)
+            safe_commit_info = {}
+            current_question[:commit_info].each do |key, value|
+              safe_commit_info[key.to_s] = value.to_s
+            end
+            question_data[:commit_info] = safe_commit_info
+          else
+            question_data[:commit_info] = current_question[:commit_info].to_s
+          end
+        end
+
+        # Add context if available (for BlameGame)
+        if current_question && current_question[:context]
+          question_data[:context] = current_question[:context].to_s
+        end
+      rescue => e
+        @renderer.log_message("Error preparing question data: #{e.message}", :red)
+        # Create a minimal fallback question
+        question_data = {
+          type: MessageType::QUESTION,
+          question_id: @game_state.current_question_id.to_s,
+          question: "Question #{@game_state.current_question_index + 1}",
+          options: ["Option 1", "Option 2", "Option 3", "Option 4"],
+          timeout: timeout,
+          round: @game_state.current_round.to_i,
+          question_number: (@game_state.current_question_index + 1).to_i,
+          total_questions: @game_state.round_questions.size.to_i
+        }
+      end
+
+      # Don't log detailed question info to prevent author lists from showing
+      @renderer.log_message("Question #{@game_state.current_question_index + 1}/#{@game_state.round_questions.size}", :cyan)
+      @renderer.log_message("Broadcasting question to players...", :cyan)
+      broadcast_message(question_data)
+
+      # Set a timer for question timeout
+      EM.add_timer(timeout) do
+        @renderer.log_message("Question timeout (#{timeout}s) - evaluating", :yellow)
+        evaluate_answers
+      end
+    end
+
+    def evaluate_answers
+      # Delegate to question manager
+      evaluation = @question_manager.evaluate_answers
+      return unless evaluation
+
+      # Update player list in sidebar to reflect new scores
+      @sidebar.update_player_list(@player_manager.player_names, @player_manager.scores)
+
+      # Broadcast results to all players
+      broadcast_message({
+        type: MessageType::ROUND_RESULT,
+        question: evaluation[:question],
+        results: evaluation[:results],
+        correct_answer: evaluation[:question][:formatted_correct_answer] || evaluation[:question][:correct_answer],
+        scores: @player_manager.sorted_scores
+      })
+
+      # Log current scores for the host
+      @renderer.log_message("Current scores:", :cyan)
+      @player_manager.sorted_scores.each do |player, score|
+        truncated_name = player.length > 15 ? "#{player[0...12]}..." : player
+        @renderer.log_message("#{truncated_name}: #{score} points", :light_blue)
+      end
+
+      # Move to next question or round
+      @game_state.move_to_next_question
+
+      if @game_state.current_question_index >= @game_state.round_questions.size
+        # End of round
+        EM.add_timer(GitGameShow::DEFAULT_CONFIG[:transition_delay]) do
+          start_next_round
+        end
+      else
+        # Next question - use mini-game specific timing if available
+        display_time = @question_manager.question_display_time
+
+        @renderer.log_message("Next question in #{display_time} seconds...", :cyan)
+        EM.add_timer(display_time) do
+          ask_next_question
+        end
+      end
+    end
+
+    def end_game
+      @game_state.end_game
+
+      # Get winner and scores
+      winner = @player_manager.top_player
+      scores = @player_manager.scores
+
+      # Notify all players
+      broadcast_message({
+        type: MessageType::GAME_END,
+        winner: winner ? winner[0].to_s : "",
+        scores: @player_manager.sorted_scores
+      })
+
+      # Display the final results
+      @renderer.draw_game_over(winner, scores)
+
+      # Reset for next game
+      @game_state.reset_game
+      @player_manager.reset_scores
+
+      # Update sidebar
+      @sidebar.update_player_list(@player_manager.player_names, @player_manager.scores)
+      @renderer.log_message("Game ended! Type 'start' to play again or 'exit' to quit.", :cyan)
+    end
+
+    def broadcast_message(message, exclude: nil)
+      @server.broadcast_message(message, exclude: exclude)
+    end
+
+    def broadcast_scoreboard
+      broadcast_message({
+        type: MessageType::SCOREBOARD,
+        scores: @player_manager.sorted_scores
+      })
+    end
+  end
+end