@socketio.on('start_game')
def handle_start_game():
    room = session.get('room')
    if room and room in games:
        game = games[room]
        if len(game['players']) >= 2:
            socketio.emit('game_starting', {'countdown': 3}, room=room)
            def start_questions():
                time.sleep(3)
                send_next_question(room)
            threading.Thread(target=start_questions).start()

class GameClient:
    def __init__(self, interface_type):
        self.interface = self._create_interface(interface_type)
    def _create_interface(self, interface_type):
        interfaces = {
            'web': WebInterface(),
            'terminal': TerminalInterface(),
            'gui': GUIInterface()
        }
        return interfaces.get(interface_type, TerminalInterface())
    def display_question(self, question_data):
        self.interface.render_question(question_data)
    def show_results(self, results):
        self.interface.render_results(results)

class GameState:
    def __init__(self):
        self.players = {}
        self.disconnected_players = {}
        self.current_question = 0
        self.question_start_time = None

    def handle_disconnect(self, player_id):
        if player_id in self.players:
            self.disconnected_players[player_id] = self.players[player_id]
            del self.players[player_id]
        if len(self.players) >= 1:
            self.notify_others_of_disconnect(player_id)
        else:
            self.pause_game()

    def handle_reconnect(self, player_id, socket_id):
        if player_id in self.disconnected_players:
            player_data = self.disconnected_players[player_id]
            player_data['socket_id'] = socket_id
            self.players[player_id] = player_data
            del self.disconnected_players[player_id]
            self.sync_player_state(player_id)

import unittest
import threading
import time

class TestMultiplayerGame(unittest.TestCase):
    def setUp(self):
        self.game_server = GameServer()
        self.test_players = ['Alice', 'Bob', 'Charlie']

    def test_simultaneous_connections(self):
        threads = []
        results = []

        def connect_player(nickname):
            result = self.game_server.add_player(nickname)
            results.append(result)

        for player in self.test_players:
            thread = threading.Thread(target=connect_player, args=(player,))
            threads.append(thread)
            thread.start()

        for thread in threads:
            thread.join()

        self.assertEqual(len(results), 3)
        self.assertTrue(all(r['success'] for r in results))

    def test_question_timing_fairness(self):
        for player in self.test_players:
            self.game_server.add_player(player)
        start_time = time.time()
        self.game_server.start_game()
        delivery_times = self.game_server.get_question_delivery_times()
        timing_difference = max(delivery_times) - min(delivery_times)
        self.assertLess(timing_difference, 0.1)

class QuestionManager:
    def __init__(self):
        self.questions = self.load_questions()
        self.difficulty_weights = {'easy': 0.4, 'medium': 0.4, 'hard': 0.2}

    def adjust_difficulty(self, player_scores):
        avg_score = sum(player_scores.values()) / len(player_scores)
        if avg_score > 0.8:
            self.difficulty_weights = {'easy': 0.2, 'medium': 0.4, 'hard': 0.4}
        elif avg_score < 0.4:
            self.difficulty_weights = {'easy': 0.6, 'medium': 0.3, 'hard': 0.1}
        else:
            self.difficulty_weights = {'easy': 0.4, 'medium': 0.4, 'hard': 0.2}

    def select_next_question(self, used_questions, player_scores):
        self.adjust_difficulty(player_scores)
        available = [q for q in self.questions if q['id'] not in used_questions]
        weighted_questions = []
        for difficulty, weight in self.difficulty_weights.items():
            difficulty_questions = [q for q in available if q['difficulty'] == difficulty]
            weighted_questions.extend(difficulty_questions * int(weight * 10))
        return random.choice(weighted_questions) if weighted_questions else None