git_game_show 0.1.4 → 0.1.5

data/lib/git_game_show/game_server.rb

@@ -78,10 +78,16 @@ module GitGameShow
 
       # Draw horizontal divider line between main area and command area
       print @cursor.move_to(0, @command_line - 1)
-      print "=" * @terminal_width
+      print "═" * (@terminal_width - @sidebar_width - 3) + "╧" + "═" * (@sidebar_width + 2)
 
       # Draw vertical divider line between main area and sidebar
-      (0...@command_line-1).each do |line|
+      print @cursor.move_to(@main_width, 0)
+      print "│"
+      print @cursor.move_to(@main_width, 1)
+      print "│"
+      print @cursor.move_to(@main_width, 2)
+      print "╞═"
+      (3...@command_line-1).each do |line|
         print @cursor.move_to(@main_width, line)
         print "│"
       end
@@ -114,16 +120,16 @@ module GitGameShow
       start_y = 8
 
       print @cursor.move_to(start_x, start_y)
-      print "┌" + "─" * (link_box_width - 2) + "┐"
+      print "╭" + "─" * (link_box_width - 2) + "╮"
 
       print @cursor.move_to(start_x, start_y + 1)
-      print "│" + " JOIN LINK (Copied to Clipboard) ".center(link_box_width - 2).colorize(:green) + "│"
+      print "│" + " Join Link (Copied to Clipboard) ".center(link_box_width - 2).colorize(:green) + "│"
 
       print @cursor.move_to(start_x, start_y + 2)
       print "│" + @join_link.center(link_box_width - 2).colorize(:yellow) + "│"
 
       print @cursor.move_to(start_x, start_y + 3)
-      print "└" + "─" * (link_box_width - 2) + "┘"
+      print "╰" + "─" * (link_box_width - 2) + "╯"
 
       # Also log that the link was copied
       log_message("Join link copied to clipboard", :green)
@@ -132,7 +138,7 @@ module GitGameShow
     def draw_sidebar
       # Draw sidebar header
       print @cursor.move_to(@main_width + 2, 1)
-      print "PLAYERS".colorize(:cyan)
+      print "Players".colorize(:cyan)
 
       print @cursor.move_to(@main_width + 2, 2)
       print "═" * (@sidebar_width - 2)
@@ -250,7 +256,7 @@ module GitGameShow
     end
 
     def display_welcome_banner
-      puts <<-BANNER.colorize(:green)
+      banner = <<-BANNER.colorize(:green)
  ██████╗ ██╗████████╗     ██████╗  █████╗ ███╗   ███╗███████╗
 ██╔════╝ ██║╚══██╔══╝    ██╔════╝ ██╔══██╗████╗ ████║██╔════╝
 ██║  ███╗██║   ██║       ██║  ███╗███████║██╔████╔██║█████╗
@@ -258,7 +264,7 @@ module GitGameShow
 ╚██████╔╝██║   ██║       ╚██████╔╝██║  ██║██║ ╚═╝ ██║███████╗
  ╚═════╝ ╚═╝   ╚═╝        ╚═════╝ ╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝
       BANNER
-      puts "\n             SERVER STARTED - PORT: #{port}\n".colorize(:light_blue)
+      banner.each{|line| puts line.center(80)}
     end
 
     private
@@ -410,22 +416,30 @@ module GitGameShow
         log_message("#{truncated_name} timed out after #{time_taken.round(2)}s ⏰", :yellow)
       else
         # Regular answer processing
-        # Calculate points for this answer
-        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
+        # For ordering quizzes, we'll calculate points in evaluate_answers
+        # using the custom scoring systems in each mini-game
+        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
+          points = 0     # Will be properly set during evaluation
+        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 with points pre-calculated
+        # Store the answer
         @player_answers[player_name] = {
           answer: answer,
           time_taken: time_taken,
@@ -439,7 +453,11 @@ module GitGameShow
 
         # Log this answer - ensure the name is not too long
         truncated_name = player_name.length > 15 ? "#{player_name[0...12]}..." : player_name
-        log_message("#{truncated_name} answered in #{time_taken.round(2)}s: #{correct ? "Correct ✓" : "Wrong ✗"}", correct ? :green : :red)
+        if current_question[:question_type] == 'ordering'
+          log_message("#{truncated_name} submitted ordering in #{time_taken.round(2)}s ⏱️", :cyan)
+        else
+          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, regardless of timeout or manual answer
@@ -458,6 +476,14 @@ module GitGameShow
         correct_answer: question[:correct_answer],
         points: points # Include points in the feedback
       }
+      
+      # For ordering quizzes, we can't determine correctness immediately
+      # Instead we'll indicate that scoring will be calculated after timeout
+      if question[:question_type] == 'ordering'
+        feedback[:correct] = nil # nil means "scoring in progress"
+        feedback[:points] = nil
+        feedback[:message] = "Ordering submitted. Points will be calculated at the end of the round."
+      end
 
       ws.send(feedback.to_json)
     end
@@ -473,46 +499,156 @@ module GitGameShow
     end
 
     def evaluate_answers
-      return unless @current_mini_game && @current_question_index < @round_questions.size
-
-      # We can't actually cancel timers in the current EM implementation
-      # Just set a flag indicating that we've already evaluated this question
+      # Safety checks
+      return unless @current_mini_game
+      return unless @round_questions && @current_question_index < @round_questions.size
       return if @question_already_evaluated
-      @question_already_evaluated = true
 
-      current_question = @round_questions[@current_question_index]
+      @question_already_evaluated = true
+      
+      # Safety check - make sure we have a current question
+      begin
+        current_question = @round_questions[@current_question_index]
+        return unless current_question # Skip if no current question
+      rescue => e
+        log_message("Error accessing current question: #{e.message}", :red)
+        return
+      end
 
-      # Use our pre-calculated answers instead of running evaluation again
-      # This ensures consistency between immediate feedback and final results
       results = {}
-      @player_answers.each do |player_name, answer_data|
-        results[player_name] = {
-          answer: answer_data[:answer],
-          correct: answer_data[:correct],
-          points: answer_data[:points]
-        }
-      end
+      
+      begin
+        # For ordering quizzes or other special types, use the mini-game's evaluation method
+        if current_question[:question_type] == 'ordering'
+          # Convert the player_answers to the format expected by the mini-game's evaluate_answers
+          mini_game_answers = {}
+          @player_answers.each do |player_name, answer_data|
+            next unless player_name && answer_data # Skip nil entries
+            
+            mini_game_answers[player_name] = {
+              answer: answer_data[:answer],
+              time_taken: answer_data[:time_taken] || 20
+            }
+          end
+          
+          # Call the mini-game's evaluate_answers method with error handling
+          begin
+            results = @current_mini_game.evaluate_answers(current_question, mini_game_answers) || {}
+          rescue => e
+            log_message("Error in mini-game evaluate_answers: #{e.message}", :red)
+            # Create fallback results
+            results = {}
+            @player_answers.each do |player_name, answer_data|
+              next unless player_name
+              
+              results[player_name] = {
+                answer: answer_data[:answer] || [],
+                correct: false,
+                points: 0,
+                partial_score: "Error calculating score"
+              }
+            end
+          end
+        else
+          # For regular quizzes, use our pre-calculated points
+          results = {}
+          @player_answers.each do |player_name, answer_data|
+            next unless player_name && answer_data # Skip nil entries
+            
+            results[player_name] = {
+              answer: answer_data[:answer] || "No answer",
+              correct: answer_data[:correct] || false,
+              points: answer_data[:points] || 0
+            }
+          end
+        end
 
-      # Update scores
-      results.each do |player, result|
-        @scores[player] += result[:points]
+        # Verify that results have required fields
+        results.each do |player_name, result|
+          # Ensure each result has the required fields with fallback values
+          results[player_name][:answer] = result[:answer] || "No answer"
+          results[player_name][:correct] = !!result[:correct] # Convert to boolean
+          results[player_name][:points] = result[:points] || 0
+        end
+        
+        # Update scores
+        results.each do |player, result|
+          @scores[player] = (@scores[player] || 0) + (result[:points] || 0)
+        end
+      rescue => e
+        log_message("Error evaluating answers: #{e.message}", :red)
       end
 
-      # Send results to all players
-      broadcast_message({
-        type: MessageType::ROUND_RESULT,
-        question: current_question,
-        results: results,
-        correct_answer: current_question[:correct_answer],
-        scores: @scores.sort_by { |_, score| -score }.to_h  # Include current scores
-      })
+      # Send results to all players - with error handling
+      begin
+        # Ensure we have valid data to broadcast
+        safe_results = {}
+        results.each do |player, result|
+          safe_results[player] = {
+            answer: result[:answer] || "No answer",
+            correct: !!result[:correct], # Convert to boolean
+            points: result[:points] || 0,
+            partial_score: result[:partial_score] || ""
+          }
+        end
+        
+        # Sort scores safely
+        safe_scores = {}
+        begin
+          safe_scores = @scores.sort_by { |_, score| -(score || 0) }.to_h
+        rescue => e
+          log_message("Error sorting scores: #{e.message}", :red)
+          safe_scores = @scores.dup # Use unsorted if sorting fails
+        end
+        
+        # For ordering questions, format the correct_answer as a list with numbers
+        formatted_correct_answer = current_question[:correct_answer] || []
+        if current_question[:question_type] == 'ordering'
+          formatted_correct_answer = current_question[:correct_answer].map.with_index do |item, idx|
+            "#{idx + 1}. #{item}" # Add numbers for easier reading
+          end
+        end
+        
+        broadcast_message({
+          type: MessageType::ROUND_RESULT,
+          question: current_question,
+          results: safe_results,
+          correct_answer: formatted_correct_answer,
+          scores: safe_scores
+        })
+      rescue => e
+        log_message("Error broadcasting results: #{e.message}", :red)
+      end
 
-      # Log current scores for the host
-      log_message("Current scores:", :cyan)
-      @scores.sort_by { |_, score| -score }.each do |player, score|
-        # Truncate player names if too long
-        truncated_name = player.length > 15 ? "#{player[0...12]}..." : player
-        log_message("#{truncated_name}: #{score} points", :light_blue)
+      # Log current scores for the host - with error handling
+      begin
+        log_message("Current scores:", :cyan)
+        
+        # Safety check for scores
+        if @scores.nil? || @scores.empty?
+          log_message("No scores available", :yellow)
+        else
+          # Sort scores safely
+          begin
+            sorted_scores = @scores.sort_by { |_, score| -(score || 0) }
+          rescue => e
+            log_message("Error sorting scores for display: #{e.message}", :red)
+            sorted_scores = @scores.to_a
+          end
+          
+          # Display each score with error handling
+          sorted_scores.each do |player_entry|
+            # Extract player and score safely
+            player = player_entry[0].to_s
+            score = player_entry[1] || 0
+            
+            # Truncate player names if too long
+            truncated_name = player.length > 15 ? "#{player[0...12]}..." : player
+            log_message("#{truncated_name}: #{score} points", :light_blue)
+          end
+        end
+      rescue => e
+        log_message("Error displaying scores: #{e.message}", :red)
       end
 
       # Move to next question or round
@@ -628,29 +764,71 @@ module GitGameShow
 
       # Send question to all players
       # Use mini-game specific timeout if available, otherwise use default
-      timeout = @current_mini_game.class.respond_to?(:question_timeout) ?
-                @current_mini_game.class.question_timeout :
-                GitGameShow::DEFAULT_CONFIG[:question_timeout]
-
-      question_data = {
-        type: MessageType::QUESTION,
-        question_id: @current_question_id,
-        question: current_question[:question],
-        options: current_question[:options],
-        timeout: timeout,
-        round: @current_round,
-        question_number: @current_question_index + 1,
-        total_questions: @round_questions.size
-      }
+      # Ensure timeout is a number
+      timeout = 0
+      begin
+        if @current_mini_game.class.respond_to?(:question_timeout)
+          timeout = @current_mini_game.class.question_timeout.to_i
+        else
+          timeout = (GitGameShow::DEFAULT_CONFIG[:question_timeout] || 20).to_i
+        end
+        # Make sure we have a positive timeout value
+        timeout = 20 if timeout <= 0
+      rescue => e
+        log_message("Error getting timeout value: #{e.message}", :red)
+        timeout = 20  # Default fallback
+      end
 
-      # Add question_type if it's a special question type (like ordering)
-      if current_question[:question_type]
-        question_data[:question_type] = current_question[:question_type]
+      # Prepare question data with type safety
+      begin
+        question_data = {
+          type: MessageType::QUESTION,
+          question_id: @current_question_id.to_s,
+          question: current_question[:question].to_s,
+          options: current_question[:options] || [],
+          timeout: timeout,  # Now guaranteed to be a number
+          round: @current_round.to_i,
+          question_number: (@current_question_index + 1).to_i,
+          total_questions: @round_questions.size.to_i
+        }
+      rescue => e
+        log_message("Error preparing question data: #{e.message}", :red)
+        # Create a minimal fallback question if something went wrong
+        question_data = {
+          type: MessageType::QUESTION,
+          question_id: "#{@current_round}-#{@current_question_index}",
+          question: "Question #{@current_question_index + 1}",
+          options: ["Option 1", "Option 2", "Option 3", "Option 4"],
+          timeout: 20,
+          round: @current_round.to_i,
+          question_number: (@current_question_index + 1).to_i,
+          total_questions: @round_questions.size.to_i
+        }
       end
 
-      # Add commit info if available (for AuthorQuiz)
-      if current_question[:commit_info]
-        question_data[:commit_info] = current_question[:commit_info]
+      # Add additional question data safely
+      begin
+        # 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
+      rescue => e
+        log_message("Error adding additional question data: #{e.message}", :red)
+        # Continue without the additional data
       end
 
       # Don't log detailed question info to prevent author lists from showing
@@ -660,7 +838,7 @@ module GitGameShow
       broadcast_message(question_data)
 
       # Set a timer for question timeout - ALWAYS evaluate after timeout
-      # Use same timeout value we sent to clients
+      # Use same timeout value we sent to clients (already guaranteed to be a number)
       EM.add_timer(timeout) do
         log_message("Question timeout (#{timeout}s) - evaluating", :yellow)
         evaluate_answers unless @current_question_index >= @round_questions.size
@@ -668,63 +846,132 @@ module GitGameShow
     end
 
     def broadcast_scoreboard
-      broadcast_message({
-        type: MessageType::SCOREBOARD,
-        scores: @scores.sort_by { |_, score| -score }.to_h
-      })
+      begin
+        # Create a safe copy of scores
+        safe_scores = {}
+        if @scores && !@scores.empty?
+          @scores.each do |player, score|
+            next unless player && player.to_s != ""
+            safe_scores[player.to_s] = score.to_i
+          end
+        end
+        
+        # Sort scores safely
+        sorted_scores = {}
+        begin
+          sorted_scores = safe_scores.sort_by { |_, score| -(score || 0) }.to_h
+        rescue => e
+          log_message("Error sorting scores for scoreboard: #{e.message}", :red)
+          sorted_scores = safe_scores  # Use unsorted if sorting fails
+        end
+        
+        broadcast_message({
+          type: MessageType::SCOREBOARD,
+          scores: sorted_scores
+        })
+      rescue => e
+        log_message("Error broadcasting scoreboard: #{e.message}", :red)
+      end
     end
 
     def end_game
       @game_state = :ended
 
-      # Safety check - make sure we have scores
-      if @scores.empty?
-        log_message("Game ended, but no scores were recorded.", :yellow)
-
-        # Reset game state for potential restart
-        @current_round = 0
-        @game_state = :lobby
-        @current_mini_game = nil
-        @round_questions = []
-        @current_question_index = 0
-        @question_already_evaluated = false
-        @player_answers = {}
+      # Initialize winner variable outside the begin block so it's visible throughout the method
+      winner = nil
+      
+      # Wrap the main logic in a begin/rescue block
+      begin
+        # Safety check - make sure we have scores and they're not nil
+        if @scores.nil? || @scores.empty?
+          log_message("Game ended, but no scores were recorded.", :yellow)
+
+          # Reset game state for potential restart
+          @current_round = 0
+          @game_state = :lobby
+          @current_mini_game = nil
+          @round_questions = []
+          @current_question_index = 0
+          @question_already_evaluated = false
+          @player_answers = {}
+          @scores = {}
+
+          # Update UI
+          update_player_list
+          log_message("Ready for a new game! Type 'start' when players have joined.", :green)
+          return
+        end
 
-        # Update UI
-        update_player_list
-        log_message("Ready for a new game! Type 'start' when players have joined.", :green)
-        return
-      end
+        # Create a safe copy of scores to work with
+        safe_scores = {}
+        @scores.each do |player, score|
+          next unless player && player != ""
+          safe_scores[player] = score || 0
+        end
+        
+        # Determine the winner with safety checks
+        begin
+          winner = safe_scores.max_by { |_, score| score || 0 }
+        rescue => e
+          log_message("Error determining winner: #{e.message}", :red)
+        end
 
-      # Determine the winner
-      winner = @scores.max_by { |_, score| score }
+        # Safety check - ensure winner isn't nil and has valid data
+        if winner.nil? || winner[0].nil? || winner[1].nil?
+          log_message("Error: Could not determine winner. No valid scores found.", :red)
+
+          # Create a synthetic winner as a fallback
+          if !safe_scores.empty?
+            # Take the first player as a last resort
+            player_name = safe_scores.keys.first.to_s
+            player_score = safe_scores.values.first || 0
+            winner = [player_name, player_score]
+            log_message("Using fallback winner: #{player_name}", :yellow)
+          else
+            # Reset and return early if we truly have no scores
+            @scores = {}
+            @current_round = 0
+            @game_state = :lobby
+            update_player_list
+            return
+          end
+        end
 
-      # Safety check - ensure winner isn't nil
-      if winner.nil?
-        log_message("Error: Could not determine winner. No valid scores found.", :red)
+        # Sort scores safely
+        sorted_scores = {}
+        begin
+          sorted_scores = safe_scores.sort_by { |_, score| -(score || 0) }.to_h
+        rescue => e
+          log_message("Error sorting scores: #{e.message}", :red)
+          sorted_scores = safe_scores # Use unsorted if sorting fails
+        end
 
-        # Reset and return early
+        # Notify all players
+        begin
+          broadcast_message({
+            type: MessageType::GAME_END,
+            winner: winner[0].to_s,
+            scores: sorted_scores
+          })
+        rescue => e
+          log_message("Error broadcasting final results: #{e.message}", :red)
+        end
+      rescue => e
+        # Catch-all for any unhandled exceptions
+        log_message("Critical error in end_game: #{e.message}", :red)
+        # Still try to reset game state
+        @game_state = :lobby
         @scores = {}
         @current_round = 0
-        @game_state = :lobby
-        update_player_list
-        return
       end
 
-      # Notify all players
-      begin
-        broadcast_message({
-          type: MessageType::GAME_END,
-          winner: winner[0],
-          scores: @scores.sort_by { |_, score| -score }.to_h
-        })
-      rescue => e
-        log_message("Error broadcasting final results: #{e.message}", :red)
+      # Display the final results on screen - with safety check
+      if winner && winner[0] && winner[1]
+        display_final_results(winner)
+      else
+        log_message("No valid winner data to display final results", :red)
       end
 
-      # Display the final results on screen
-      display_final_results(winner)
-
       # Reset game state for potential restart
       @scores = {}
       @current_round = 0
@@ -751,25 +998,47 @@ module GitGameShow
 
     def display_final_results(winner)
       begin
+        # Safety check - make sure we have a main_width value
+        main_width = @main_width || 80
+        
         # Use log messages instead of clearing screen
-        divider = "=" * (@main_width - 5)
+        divider = "=" * (main_width - 5)
         log_message(divider, :yellow)
         log_message("🏆 GAME OVER - FINAL SCORES 🏆", :yellow)
 
-        # Safety check for winner
+        # Safety check for winner - we already checked in end_game but double-check here
         if !winner || !winner[0] || !winner[1]
           log_message("Error: Invalid winner data", :red)
           log_message("Ready for a new game! Type 'start' when players have joined.", :green)
           return
         end
 
-        # Announce winner
-        winner_name = winner[0].to_s
-        winner_name = winner_name.length > 20 ? "#{winner_name[0...17]}..." : winner_name
-        log_message("Winner: #{winner_name} with #{winner[1]} points!", :green)
+        # Announce winner with defensive processing
+        begin
+          winner_name = winner[0].to_s
+          winner_name = winner_name.length > 20 ? "#{winner_name[0...17]}..." : winner_name
+          winner_score = winner[1].to_i
+          log_message("Winner: #{winner_name} with #{winner_score} points!", :green)
+        rescue => e
+          log_message("Error displaying winner: #{e.message}", :red)
+          log_message("A winner was determined but couldn't be displayed", :yellow)
+        end
 
+        # Create a safe copy of scores to work with
+        safe_scores = {}
+        begin
+          if @scores && !@scores.empty?
+            @scores.each do |player, score|
+              next unless player && player.to_s != ""
+              safe_scores[player.to_s] = score.to_i
+            end
+          end
+        rescue => e
+          log_message("Error copying scores: #{e.message}", :red)
+        end
+        
         # Safety check for scores
-        if @scores.nil? || @scores.empty?
+        if safe_scores.empty?
           log_message("No scores available to display", :yellow)
           log_message(divider, :yellow)
           log_message("Ready for a new game! Type 'start' when players have joined.", :green)
@@ -782,65 +1051,91 @@ module GitGameShow
         leaderboard_entries = []
 
         # Sort scores safely
+        sorted_scores = []
         begin
-          sorted_scores = @scores.sort_by { |_, score| -(score || 0) }
+          sorted_scores = safe_scores.sort_by { |_, score| -(score || 0) }.to_a
         rescue => e
-          log_message("Error sorting scores: #{e.message}", :red)
-          sorted_scores = @scores.to_a
+          log_message("Error sorting scores for display: #{e.message}", :red)
+          sorted_scores = safe_scores.to_a
         end
 
-        # Show limited entries in console
-        sorted_scores.take(10).each_with_index do |(name, score), index|
-          # Safely handle name and score
-          player_name = name.to_s
-          player_score = score || 0
-
-          # Truncate name if needed
-          display_name = player_name.length > 15 ? "#{player_name[0...12]}..." : player_name
-
-          # Format based on position
-          case index
-          when 0
-            log_message("🥇 #{display_name}: #{player_score} points", :yellow)
-          when 1
-            log_message("🥈 #{display_name}: #{player_score} points", :light_blue)
-          when 2
-            log_message("🥉 #{display_name}: #{player_score} points", :light_magenta)
-          else
-            log_message("#{(index + 1).to_s}. #{display_name}: #{player_score} points", :white)
+        max_to_show = 10
+        
+        # Show limited entries in console with extra safety checks
+        begin
+          # Ensure we don't try to take more entries than exist
+          entries_to_show = [sorted_scores.size, max_to_show].min
+          
+          sorted_scores.take(entries_to_show).each_with_index do |score_entry, index|
+            # Extra safety check for each entry
+            next unless score_entry && score_entry.is_a?(Array) && score_entry.size >= 2
+            
+            name = score_entry[0]
+            score = score_entry[1]
+            
+            # Safely handle name and score
+            player_name = name.to_s
+            player_score = score.to_i
+
+            # Truncate name if needed
+            display_name = player_name.length > 15 ? "#{player_name[0...12]}..." : player_name
+
+            # Format based on position
+            case index
+            when 0
+              log_message("🥇 #{display_name}: #{player_score} points", :yellow)
+            when 1
+              log_message("🥈 #{display_name}: #{player_score} points", :light_blue)
+            when 2
+              log_message("🥉 #{display_name}: #{player_score} points", :light_magenta)
+            else
+              log_message("#{(index + 1).to_s}. #{display_name}: #{player_score} points", :white)
+            end
           end
+        rescue => e
+          log_message("Error displaying leaderboard entries: #{e.message}", :red)
         end
 
         # If there are more players than shown, add a note
-        if sorted_scores.size > 10
-          log_message("... and #{sorted_scores.size - 10} more (see full results in file)", :light_black)
+        if sorted_scores.size > max_to_show
+          log_message("... and #{sorted_scores.size - max_to_show} more (see full results in file)", :light_black)
         end
 
-        # Build complete entries array for file
-        sorted_scores.each_with_index do |(name, score), index|
-          # Use safe values
-          player_name = name.to_s
-          player_score = score || 0
-
-          # Add medals for file format
-          medal = case index
-                  when 0 then "🥇"
-                  when 1 then "🥈"
-                  when 2 then "🥉"
-                  else "#{index + 1}."
-                  end
-
-          leaderboard_entries << "#{medal} #{player_name}: #{player_score} points"
+        # Build complete entries array for file with safety checks
+        begin
+          sorted_scores.each_with_index do |score_entry, index|
+            # Skip invalid entries
+            next unless score_entry && score_entry.is_a?(Array) && score_entry.size >= 2
+            
+            # Use safe values
+            player_name = score_entry[0].to_s
+            player_score = score_entry[1].to_i
+
+            # Add medals for file format
+            medal = case index
+                    when 0 then "🥇"
+                    when 1 then "🥈"
+                    when 2 then "🥉"
+                    else "#{index + 1}."
+                    end
+
+            leaderboard_entries << "#{medal} #{player_name}: #{player_score} points"
+          end
+        rescue => e
+          log_message("Error preparing leaderboard entries for file: #{e.message}", :red)
         end
 
-        # Save leaderboard to file
-        filename = save_leaderboard_to_file(winner, leaderboard_entries)
+        # Only try to save file if we have entries
+        filename = nil
+        if !leaderboard_entries.empty? && winner
+          filename = save_leaderboard_to_file(winner, leaderboard_entries)
+        end
 
         log_message(divider, :yellow)
         if filename
           log_message("Leaderboard saved to: #{filename}", :cyan)
         else
-          log_message("Failed to save leaderboard to file", :red)
+          log_message("No leaderboard file generated", :yellow)
         end
         log_message("Ready for a new game! Type 'start' when players have joined.", :green)
       rescue => e
@@ -852,17 +1147,23 @@ module GitGameShow
 
     def save_leaderboard_to_file(winner, leaderboard_entries)
       begin
-        # Validate parameters
-        if !winner || !leaderboard_entries
-          log_message("Error: Invalid data for leaderboard file", :red)
+        # Validate parameters with thorough checks
+        if !winner || !winner.is_a?(Array) || winner.size < 2 || winner[0].nil? || winner[1].nil?
+          log_message("Error: Invalid winner data for leaderboard file", :red)
+          return nil
+        end
+        
+        if !leaderboard_entries || !leaderboard_entries.is_a?(Array) || leaderboard_entries.empty?
+          log_message("Error: Invalid entries data for leaderboard file", :red)
           return nil
         end
 
         # Create a unique filename with timestamp
-        timestamp = Time.now.strftime("%Y%m%d_%H%M%S")
+        timestamp = Time.now.strftime("%Y%m%d_%H%M%S") rescue "unknown_time"
         filename = "git_game_show_results_#{timestamp}.txt"
 
         # Use a base path that should be writable
+        file_path = nil
         begin
           # First try current directory
           file_path = File.join(Dir.pwd, filename)
@@ -873,56 +1174,88 @@ module GitGameShow
             file_path = File.join(Dir.home, filename)
             filename = File.join(Dir.home, filename) # Update filename to show full path
           end
-        rescue
+        rescue => e
+          log_message("Error with file path: #{e.message}", :red)
           # If all else fails, use /tmp (Unix) or %TEMP% (Windows)
-          temp_dir = ENV['TEMP'] || ENV['TMP'] || '/tmp'
-          file_path = File.join(temp_dir, filename)
-          filename = file_path # Update filename to show full path
+          begin
+            temp_dir = ENV['TEMP'] || ENV['TMP'] || '/tmp'
+            file_path = File.join(temp_dir, filename)
+            filename = file_path # Update filename to show full path
+          rescue => e2
+            log_message("Error setting up temp file path: #{e2.message}", :red)
+            return nil
+          end
+        end
+
+        # Make sure we have a valid file path
+        unless file_path && !file_path.empty?
+          log_message("Could not determine a valid file path for leaderboard", :red)
+          return nil
         end
 
         # Get repo name from git directory path safely
+        repo_name = "Unknown"
+        begin
+          if @repo && @repo.respond_to?(:dir) && @repo.dir && @repo.dir.respond_to?(:path)
+            path = @repo.dir.path
+            repo_name = path ? File.basename(path) : "Unknown"
+          end
+        rescue => e
+          log_message("Error getting repo name: #{e.message}", :yellow)
+        end
+
+        # Get player count safely
+        player_count = 0
         begin
-          repo_name = @repo && @repo.dir ? File.basename(@repo.dir.path) : "Unknown"
-        rescue
-          repo_name = "Unknown"
+          player_count = @players && @players.respond_to?(:keys) ? @players.keys.size : 0
+        rescue => e
+          log_message("Error getting player count: #{e.message}", :yellow)
         end
 
-        File.open(file_path, "w") do |file|
-          # Write header
-          file.puts "GIT GAME SHOW - FINAL RESULTS"
-          file.puts "==========================="
-          file.puts "Date: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
-          file.puts "Repository: #{repo_name}"
-          file.puts "Players: #{@players.keys.size}"
-          file.puts ""
+        # Extract winner data safely
+        winner_name = "Unknown"
+        winner_score = 0
+        begin
+          winner_name = winner[0].to_s
+          winner_score = winner[1].to_i
+        rescue => e
+          log_message("Error extracting winner data: #{e.message}", :yellow)
+        end
 
-          # Write winner safely
-          begin
-            winner_name = winner[0].to_s
-            winner_score = winner[1].to_i
+        # Write the file with error handling
+        begin
+          File.open(file_path, "w") do |file|
+            # Write header
+            file.puts "Git Game Show - Final Results"
+            file.puts "═════════════════════════════"
+            file.puts "Date: #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}"
+            file.puts "Repository: #{repo_name}"
+            file.puts "Players: #{player_count}"
+            file.puts ""
+
+            # Write winner
             file.puts "WINNER: #{winner_name} with #{winner_score} points!"
-          rescue
-            file.puts "WINNER: Unknown (error retrieving winner data)"
-          end
-          file.puts ""
+            file.puts ""
 
-          # Write full leaderboard
-          file.puts "FULL LEADERBOARD:"
-          file.puts "---------------"
-          if leaderboard_entries.empty?
-            file.puts "No entries recorded"
-          else
+            # Write full leaderboard
+            file.puts "Full Leaderboard:"
+            file.puts "─────────────────"
             leaderboard_entries.each do |entry|
               file.puts entry.to_s
+            rescue => e
+              file.puts "Error with entry: #{e.message}"
             end
+
+            # Write footer
+            file.puts ""
+            file.puts "Thanks for playing Git Game Show!"
           end
 
-          # Write footer
-          file.puts ""
-          file.puts "Thanks for playing Git Game Show!"
+          return filename
+        rescue => e
+          log_message("Error writing leaderboard file: #{e.message}", :red)
+          return nil
         end
-
-        return filename
       rescue => e
         log_message("Error saving leaderboard: #{e.message}", :red)
         return nil
@@ -932,10 +1265,44 @@ module GitGameShow
     # Removed old full-screen methods as we now use log_message based approach
 
     def broadcast_message(message, exclude: nil)
-      @players.each do |player_name, ws|
-        # Skip excluded player if specified
-        next if exclude && player_name == exclude
-        ws.send(message.to_json)
+      return if message.nil?
+      
+      begin
+        # Convert message to JSON safely
+        json_message = nil
+        begin
+          json_message = message.to_json
+        rescue => e
+          log_message("Error converting message to JSON: #{e.message}", :red)
+          
+          # 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
+        
+        # Send to each player with error handling
+        @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
+            log_message("Error sending to #{player_name}: #{e.message}", :yellow)
+            # We don't remove the player here, as they might just have temporary connection issues
+          end
+        end
+      rescue => e
+        log_message("Fatal error in broadcast_message: #{e.message}", :red)
       end
     end
 
@@ -1070,34 +1437,30 @@ module GitGameShow
       if !@ui_drawn
         system("clear") || system("cls")
 
-        # Header - only show on first draw
-        puts <<-HEADER.colorize(:green)
- ██████╗ ██╗████████╗     ██████╗  █████╗ ███╗   ███╗███████╗
-██╔════╝ ██║╚══██╔══╝    ██╔════╝ ██╔══██╗████╗ ████║██╔════╝
-██║  ███╗██║   ██║       ██║  ███╗███████║██╔████╔██║█████╗
-██║   ██║██║   ██║       ██║   ██║██╔══██║██║╚██╔╝██║██╔══╝
-╚██████╔╝██║   ██║       ╚██████╔╝██║  ██║██║ ╚═╝ ██║███████╗
- ╚═════╝ ╚═╝   ╚═╝        ╚═════╝ ╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝
-        HEADER
+        display_welcome_banner
+
+        puts "\n             Server Started - Port: #{port}\n".colorize(:light_blue).center(80)
+
+        @ui_drawn = true
       else
         # Just print a separator for subsequent updates
-        puts "\n\n" + ("=" * 60)
-        puts "GIT GAME SHOW - STATUS UPDATE".center(60).colorize(:green)
-        puts ("=" * 60)
+        puts "\n\n" + ("═" * 60)
+        puts "Git Game Show - Status Update".center(60).colorize(:green)
+        puts ("═" * 60)
       end
 
       # Server info
-      puts "\n==================== SERVER INFO ====================".colorize(:cyan)
+      puts "\n════════════════════ Server Info ════════════════════".colorize(:cyan)
       puts "Status: #{game_state_text}".colorize(game_state_color)
       puts "Rounds: #{@current_round}/#{rounds}".colorize(:light_blue)
       puts "Repository: #{repo.dir.path}".colorize(:light_blue)
 
       # Display join link prominently
-      puts "\n==================== JOIN LINK =====================".colorize(:green)
+      puts "\n════════════════════ Join Link ═════════════════════".colorize(:green)
       puts @join_link.to_s.colorize(:yellow)
 
       # Player list
-      puts "\n==================== PLAYERS =======================".colorize(:cyan)
+      puts "\n════════════════════ Players ═══════════════════════".colorize(:cyan)
       if @players.empty?
         puts "No players have joined yet".colorize(:yellow)
       else
@@ -1113,13 +1476,13 @@ module GitGameShow
         puts "Players can join using the link above.".colorize(:yellow)
         puts "Type 'players' to see the current list of players.".colorize(:yellow)
       when :playing
-        puts "\n==================== GAME INFO =======================".colorize(:cyan)
+        puts "\n════════════════════ Game Info ═══════════════════════".colorize(:cyan)
         puts "Current round: #{@current_round}/#{rounds}".colorize(:light_blue)
         puts "Current mini-game: #{@current_mini_game&.class&.name || 'N/A'}".colorize(:light_blue)
         puts "Question: #{@current_question_index + 1}/#{@round_questions.size}".colorize(:light_blue) if @round_questions&.any?
 
         # Show scoreboard
-        puts "\n=================== SCOREBOARD ======================".colorize(:cyan)
+        puts "\n═══════════════════ Scoreboard ══════════════════════".colorize(:cyan)
         if @scores.empty?
           puts "No scores yet".colorize(:yellow)
         else
@@ -1149,7 +1512,8 @@ module GitGameShow
     end
 
     def print_help_message
-      puts "\n==================== HELP =========================="
+      puts ""
+      puts "═══════════════════ Help ═════════════════════════"
       puts "Available commands:"
       puts "  help    - Show this help message"
       puts "  start   - Start the game with current players"
@@ -1157,7 +1521,7 @@ module GitGameShow
       puts "  status  - Refresh the status display"
       puts "  end     - End the current game"
       puts "  exit    - Shut down the server and exit"
-      puts "=================================================="
+      puts "══════════════════════════════════════════════════"
     end
 
     def print_status_message(message, status)
@@ -1188,10 +1552,22 @@ module GitGameShow
 
     # Select the next mini-game to ensure variety and avoid repetition
     def select_next_mini_game
+      # Special case for when only one mini-game type is enabled
+      if @mini_games.size == 1
+        selected_game = @mini_games.first
+        log_message("Only one mini-game type available: #{selected_game.name}", :light_black)
+        return selected_game
+      end
+      
       # If we have no more available mini-games, reset the cycle
       if @available_mini_games.empty?
-        # Repopulate with all mini-games except the last one used
-        @available_mini_games = @mini_games.reject { |game| game == @used_mini_games.last }
+        # Handle the case where we might have only one game left after excluding the last used
+        if @mini_games.size <= 2
+          @available_mini_games = @mini_games.dup
+        else
+          # Repopulate with all mini-games except the last one used (if possible)
+          @available_mini_games = @mini_games.reject { |game| game == @used_mini_games.last }
+        end
 
         # Log that we're starting a new cycle
         log_message("Starting a new cycle of mini-games", :light_black)
@@ -1199,6 +1575,7 @@ module GitGameShow
 
       # Select a random game from the available ones
       selected_game = @available_mini_games.sample
+      return @mini_games.first if selected_game.nil? # Fallback for safety
 
       # Remove the selected game from available and add to used
       @available_mini_games.delete(selected_game)
@@ -1214,9 +1591,9 @@ module GitGameShow
     def load_mini_games
       # Enable all mini-games
       [
-        GitGameShow::AuthorQuiz,
-        GitGameShow::CommitMessageQuiz,
-        GitGameShow::CommitMessageCompletion,
+        # GitGameShow::AuthorQuiz,
+        # GitGameShow::CommitMessageQuiz,
+        # GitGameShow::CommitMessageCompletion,
         GitGameShow::DateOrderingQuiz
       ]
     end