git_game_show 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c1276258a9e2d5888ea51d9c44275c81a6b062b6b0be1959ad35e707f8d0b25
-  data.tar.gz: 1a0de92893ef2f8fd80762f0c36e00516ffbdd1d46c77c36afca4dfcac30ef26
+  metadata.gz: 3abc81a3656def2b0880a2e4127ceeca7cf43e101a774ce6ff5f4fd4a5dc2340
+  data.tar.gz: 5ac77e86bfc2814742302ab80a56594dc956add3beeae6f3bd2b6368060f98ac
 SHA512:
-  metadata.gz: c30984bf5db7535d12ea5ce36d4dfbeaf02856676bcad043da143ee7a0e142b5f3406c50f761de03c812bcf090754c9119b2155c446b3f57967ba0fda58ae9bf
-  data.tar.gz: b2a882dec2a57908ebcd4574aee757df13ba3cdf084f642f6ff5775d65dc8ff224d1244dcf08e3f2eebb2ec04f2fab05d18e7520c6d040b2b4045cdcd87022eb
+  metadata.gz: b0ed039456447007b222d5a48a3175593ba059faebff0be7bf056e044afd6128fd508b9a598b9f1de95294260a220eaa3010b65408b707686b05e6dfe5078e2a
+  data.tar.gz: 5a4e54ec376ee4036697b83be7629099d6fbff2f6988b7055b246adc0a4d9f251dafb4ce0ea38fe75c0fa538a3eac10bd0b299674b9e493f6c5c0c526730b45e

data/README.md

@@ -114,6 +114,10 @@ The game includes several mini-games based on Git repository data:
 
 MIT
 
+## Inspiration
+
+Git Game Show was inspired by https://github.com/jsomers/git-game.
+
 ## Contributing
 
 1. Fork the repository

data/lib/git_game_show/core/game_state.rb

@@ -0,0 +1,120 @@
+module GitGameShow
+  # Manages the state of the game
+  class GameState
+    attr_reader :state, :current_round, :total_rounds, :current_mini_game
+    attr_reader :round_questions, :current_question_index, :question_start_time
+    attr_reader :player_answers, :current_question_id, :question_already_evaluated
+
+    def initialize(total_rounds)
+      @total_rounds = total_rounds
+      @current_round = 0
+      @state = :lobby  # :lobby, :playing, :ended
+      @current_mini_game = nil
+      @round_questions = []
+      @current_question_index = 0
+      @question_start_time = nil
+      @player_answers = {}
+      @current_question_id = nil
+      @question_already_evaluated = false
+      @used_mini_games = []  # Track which mini-games have been used
+      @available_mini_games = []  # Mini-games still available in the current cycle
+    end
+
+    def lobby?
+      @state == :lobby
+    end
+
+    def playing?
+      @state == :playing
+    end
+
+    def ended?
+      @state == :ended
+    end
+
+    def start_game
+      return false unless @state == :lobby
+      @state = :playing
+      @current_round = 0
+      # Reset the mini-game tracking for a new game
+      @used_mini_games = []
+      @available_mini_games = []
+      true
+    end
+
+    def end_game
+      @state = :ended
+      true
+    end
+
+    def reset_game
+      @state = :lobby
+      @current_round = 0
+      @current_mini_game = nil
+      @round_questions = []
+      @current_question_index = 0
+      @question_already_evaluated = false
+      @player_answers = {}
+      true
+    end
+
+    def start_next_round(mini_game)
+      @current_round += 1
+      # Reset question evaluation flag for the new round
+      @question_already_evaluated = false
+      
+      # Set the current mini-game
+      @current_mini_game = mini_game
+      true
+    end
+
+    def set_round_questions(questions)
+      @round_questions = questions
+      @current_question_index = 0
+      true
+    end
+
+    def prepare_next_question
+      return false if @current_question_index >= @round_questions.size
+      
+      @question_already_evaluated = false
+      @current_question_id = "#{@current_round}-#{@current_question_index}"
+      @question_start_time = Time.now
+      @player_answers = {}
+      true
+    end
+
+    def current_question
+      return nil if @current_question_index >= @round_questions.size
+      @round_questions[@current_question_index]
+    end
+
+    def move_to_next_question
+      @current_question_index += 1
+      @player_answers = {}
+      @question_already_evaluated = false
+    end
+
+    def last_question_in_round?
+      @current_question_index >= @round_questions.size - 1
+    end
+
+    def last_round?
+      @current_round >= @total_rounds
+    end
+
+    def record_player_answer(player_name, answer, time_taken, correct = nil, points = 0)
+      @player_answers[player_name] = {
+        answer: answer,
+        time_taken: time_taken,
+        answered: true,
+        correct: correct,
+        points: points
+      }
+    end
+
+    def mark_question_evaluated
+      @question_already_evaluated = true
+    end
+  end
+end

data/lib/git_game_show/core/mini_game_loader.rb

@@ -0,0 +1,55 @@
+module GitGameShow
+  # Handles loading and selecting mini-games
+  class MiniGameLoader
+    attr_reader :mini_games
+
+    def initialize
+      @mini_games = load_mini_games
+      @used_mini_games = []
+      @available_mini_games = []
+    end
+
+    def select_next_mini_game
+      # Special case for when only one mini-game type is enabled
+      if @mini_games.size == 1
+        return @mini_games.first.new
+      end
+
+      # If we have no more available mini-games, reset the cycle
+      if @available_mini_games.empty?
+        # 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
+      end
+
+      # Select a random game from the available ones
+      selected_game = @available_mini_games.sample
+      return @mini_games.first.new if selected_game.nil? # Fallback for safety
+
+      # Remove the selected game from available and add to used
+      @available_mini_games.delete(selected_game)
+      @used_mini_games << selected_game
+
+      # Return a new instance of the selected game class
+      selected_game.new
+    end
+
+    private
+
+    def load_mini_games
+      # Enable all mini-games
+      [
+        GitGameShow::AuthorQuiz,
+        GitGameShow::FileQuiz,
+        GitGameShow::CommitMessageCompletion,
+        GitGameShow::DateOrderingQuiz,
+        GitGameShow::BranchDetective,
+        GitGameShow::BlameGame
+      ]
+    end
+  end
+end

data/lib/git_game_show/core/player_manager.rb

@@ -0,0 +1,61 @@
+module GitGameShow
+  # Manages player connections, scores, and related operations
+  class PlayerManager
+    attr_reader :players, :scores
+
+    def initialize
+      @players = {}  # WebSocket connections by player name
+      @scores = {}   # Player scores
+    end
+
+    def add_player(name, ws)
+      return false if @players.key?(name)
+      @players[name] = ws
+      @scores[name] = 0
+      true
+    end
+
+    def remove_player(name)
+      return false unless @players.key?(name)
+      @players.delete(name)
+      true
+    end
+
+    def find_player_by_ws(ws)
+      @players.key(ws)
+    end
+
+    def player_exists?(name)
+      @players.key?(name)
+    end
+
+    def get_ws(name)
+      @players[name]
+    end
+
+    def player_count
+      @players.size
+    end
+
+    def player_names
+      @players.keys
+    end
+
+    def update_score(name, points)
+      @scores[name] = (@scores[name] || 0) + points
+    end
+
+    def reset_scores
+      @players.keys.each { |name| @scores[name] = 0 }
+    end
+
+    def sorted_scores
+      @scores.sort_by { |_, score| -score }.to_h
+    end
+
+    def top_player
+      sorted = sorted_scores
+      sorted.empty? ? nil : sorted.first
+    end
+  end
+end

data/lib/git_game_show/core/question_manager.rb

@@ -0,0 +1,120 @@
+module GitGameShow
+  # Manages question generation, evaluation, and scoring
+  class QuestionManager
+    def initialize(game_state, player_manager)
+      @game_state = game_state
+      @player_manager = player_manager
+    end
+
+    def generate_questions(repo)
+      mini_game = @game_state.current_mini_game
+      return [] unless mini_game
+
+      begin
+        questions = mini_game.generate_questions(repo)
+        @game_state.set_round_questions(questions)
+        questions
+      rescue => e
+        # Handle error gracefully
+        []
+      end
+    end
+
+    def evaluate_answers
+      return false if @game_state.question_already_evaluated
+      
+      @game_state.mark_question_evaluated
+      current_question = @game_state.current_question
+      return false unless current_question
+
+      mini_game = @game_state.current_mini_game
+      return false unless mini_game
+
+      player_answers = @game_state.player_answers
+
+      results = {}
+
+      if current_question[:question_type] == 'ordering'
+        # Convert player_answers to the format expected by mini-game's evaluate_answers
+        mini_game_answers = {}
+        player_answers.each do |player_name, answer_data|
+          next unless player_name && answer_data
+          
+          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
+        begin
+          results = mini_game.evaluate_answers(current_question, mini_game_answers) || {}
+        rescue => e
+          # Create fallback results in case of error
+          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 pre-calculated points
+        player_answers.each do |player_name, answer_data|
+          next unless player_name && answer_data
+
+          results[player_name] = {
+            answer: answer_data[:answer] || "No answer",
+            correct: answer_data[:correct] || false,
+            points: answer_data[:points] || 0
+          }
+        end
+      end
+
+      # Update scores in player manager
+      results.each do |player, result|
+        @player_manager.update_score(player, result[:points] || 0)
+      end
+
+      # Format correct answer for ordering questions
+      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
+        current_question[:formatted_correct_answer] = formatted_correct_answer
+      end
+
+      # Return the results and the current question
+      return {
+        results: results,
+        question: current_question
+      }
+    end
+
+    def question_timeout
+      # Get mini-game specific timeout if available
+      if @game_state.current_mini_game.class.respond_to?(:question_timeout)
+        timeout = @game_state.current_mini_game.class.question_timeout.to_i
+        return timeout > 0 ? timeout : 20
+      end
+      
+      # Default timeout
+      GitGameShow::DEFAULT_CONFIG[:question_timeout] || 20
+    end
+
+    def question_display_time
+      # Get mini-game specific display time if available
+      if @game_state.current_mini_game.class.respond_to?(:question_display_time)
+        display_time = @game_state.current_mini_game.class.question_display_time.to_i
+        return display_time > 0 ? display_time : 5
+      end
+      
+      # Default display time
+      GitGameShow::DEFAULT_CONFIG[:question_display_time] || 5
+    end
+  end
+end