Skip to content
TheChatArchiveThe Chat Archive
Metallama-4-maverick-03-26-experimental· MetaHugging Face LMArena Human Preference 140K

Teach basics of Flutter by creating a basic simple cross platform app like a quiz in…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.5-pro’s answer.
  1. User

    Teach basics of Flutter by creating a basic simple cross platform app like a quiz in Flutter and player 1 + host in desktop player 2 mobile player 3 mobile or desktop player 1 starts game player2,3 joins game questions loaded from json format file 1 question + 4 answer options 12 questions, each question 60 sec to answer, then next question send to all players after 12 question, leader board send to all players

  2. Meta Assistant

    Let's build a simple cross-platform quiz app in Flutter. We'll cover:

    1. Basic Flutter structure (Widgets, State Management)
    2. JSON data loading (questions & answers)
    3. Multiplayer simulation (Host + Players via WebSockets)
    4. Timer & Question Flow (60s per Q, auto-next)
    5. Leaderboard display (final scores)

    Step 1: Set Up Flutter Project

    flutter create quiz_multiplayer
    cd quiz_multiplayer
    flutter pub add web_socket_channel # For real-time comms
    flutter pub add path_provider # To load local JSON file
    flutter pub get
    

    Step 2: JSON Data (questions.json) Create assets/questions.json in your project root:

    [
      {
        "question": "Who wrote 'To Kill a Mockingbird'?",
        "options": ["Harper Lee", "J.K. Rowling", "Stephen King", "Ernest Hemingway"],
        "correct": 0
      },
      {
        "question": "What is the capital of France?",
        "options": ["Paris", "London", "Berlin", "Madrid"],
        "correct": 0
      },
      // ... 10 more questions like this
      {
        "question": "Which planet is known as the Red Planet?",
        "options": ["Earth", "Mars", "Jupiter", "Saturn"],
        "correct": 1
      }
    ]
    

    Add assets/questions.json to pubspec.yaml:

    flutter:
      assets:
        - assets/questions.json
    

    Step 3: Models (question.dart) Create lib/models/question.dart:

    class Question {
      final String question;
      final List<String> options;
      final int correct;
    
      Question({required this.question, required this.options, required this.correct});
    
      factory Question.fromJson(Map<String, dynamic> json) {
        return Question(
          question: json['question'],
          options: List<String>.from(json['options']),
          correct: json['correct'],
        );
      }
    }
    

    Step 4: Quiz Logic (quiz_service.dart) Create lib/services/quiz_service.dart:

    import 'dart:convert';
    import 'package:flutter/services.dart' show rootBundle;
    import '../models/question.dart';
    
    class QuizService {
      List<Question> _questions = [];
      int _currentQuestionIndex = 0;
    
      Future<void> loadQuestions() async {
        final String jsonString = await rootBundle.loadString('assets/questions.json');
        final List<dynamic> jsonList = jsonDecode(jsonString);
        _questions = jsonList.map((json) => Question.fromJson(json)).toList();
      }
    
      Question get currentQuestion => _questions[_currentQuestionIndex];
      bool get hasNextQuestion => _currentQuestionIndex < _questions.length - 1;
      
      void nextQuestion() => _currentQuestionIndex++;
      int get questionCount => _questions.length;
    }
    

    Step 5: WebSocket Server (for multiplayer) We'll simulate a simple server using web_socket_channel. Create lib/services/quiz_server.dart:

    import 'package:web_socket_channel/web_socket_channel.dart';
    import 'package:web_socket_channel/html.dart' as html;
    
    class QuizServer {
      final _channel = html.WebSocketChannel.connect(Uri.parse('ws://localhost:8080'));
      final _players = <String, WebSocketChannel>{};
    
      void startServer() {
        html.HttpServer.bind('localhost', 8080).then((server) {
          server.listen((request) {
            if (WebSocketTransformer.isUpgradeRequest(request)) {
              WebSocketTransformer.upgrade(request).then((webSocket) {
                final playerId = 'Player${_players.length + 1}';
                _players[playerId] = WebSocketChannel(webSocket);
                _broadcast('$playerId joined!');
              });
            }
          });
        });
      }
    
      void _broadcast(String message) {
        _players.values.forEach((channel) => channel.sink.add(message));
      }
    
      Stream<String> get messages => _channel.stream.cast<String>();
    }
    

    Step 6: Host Screen (Desktop) Create lib/screens/host_screen.dart:

    import 'package:flutter/material.dart';
    import '../services/quiz_service.dart';
    import '../services/quiz_server.dart';
    
    class HostScreen extends StatefulWidget {
      @override
      _HostScreenState createState() => _HostScreenState();
    }
    
    class _HostScreenState extends State<HostScreen> {
      final _quizService = QuizService();
      final _quizServer = QuizServer();
      bool _gameStarted = false;
      String _currentPlayerStatus = '';
    
      @override
      void initState() {
        super.initState();
        _quizService.loadQuestions().then((_) => _quizServer.startServer());
        _listenToPlayers();
      }
    
      void _listenToPlayers() {
        _quizServer.messages.listen((message) {
          setState(() => _currentPlayerStatus = message);
          if (message.contains('ready')) _startGame();
        });
      }
    
      void _startGame() {
        setState(() => _gameStarted = true);
        _sendNextQuestion();
      }
    
      void _sendNextQuestion() {
        if (_quizService.hasNextQuestion) {
          final question = _quizService.currentQuestion;
          _quizServer._broadcast('question|${question.question}|${question.options.join(',')}|60');
          _quizService.nextQuestion();
          Future.delayed(Duration(seconds: 60), _sendNextQuestion);
        } else {
          _quizServer._broadcast('leaderboard|${_getLeaderboard()}');
        }
      }
    
      String _getLeaderboard() {
        // Simulate scores (in real app, track answers)
        return 'Player1: 8/12, Player2: 6/12, Player3: 9/12';
      }
    
      @override
      Widget build(BuildContext context) {
        return Scaffold(
          appBar: AppBar(title: Text('Quiz Host')),
          body: Center(
            child: Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                Text(_gameStarted ? 'Game Started!' : 'Waiting for players...'),
                Text(_currentPlayerStatus),
                ElevatedButton(
                  onPressed: _gameStarted ? null : _startGame,
                  child: Text('Start Game'),
                ),
              ],
            ),
          ),
        );
      }
    }
    

    Step 7: Player Screen (Mobile/Desktop) Create lib/screens/player_screen.dart:

    import 'package:flutter/material.dart';
    import 'package:web_socket_channel/io.dart';
    import 'package:web_socket_channel/web_socket_channel.dart';
    
    class PlayerScreen extends StatefulWidget {
      final String playerId;
    
      PlayerScreen({required this.playerId});
    
      @override
      _PlayerScreenState createState() => _PlayerScreenState();
    }
    
    class _PlayerScreenState extends State<PlayerScreen> {
      late WebSocketChannel _channel;
      String _currentQuestion = '';
      List<String> _options = [];
      int _remainingTime = 0;
      String _selectedAnswer = '';
      String _leaderboard = '';
    
      @override
      void initState() {
        super.initState();
        _channel = IOWebSocketChannel.connect('ws://YOUR_HOST_IP:8080');
        _channel.sink.add('${widget.playerId} ready');
        _listenToServer();
      }
    
      void _listenToServer() {
        _channel.stream.listen((message) {
          if (message.startsWith('question|')) {
            final parts = message.split('|');
            setState(() {
              _currentQuestion = parts[1];
              _options = parts[2].split(',');
              _remainingTime = int.parse(parts[3]);
              _startTimer();
            });
          } else if (message.startsWith('leaderboard|')) {
            setState(() => _leaderboard = message.split('|')[1]);
          }
        });
      }
    
      void _startTimer() {
        Future.doWhile(() async {
          await Future.delayed(Duration(seconds: 1));
          setState(() => _remainingTime--);
          return _remainingTime > 0;
        }).then((_) => _submitAnswer());
      }
    
      void _submitAnswer() {
        // Simulate sending answer (real app tracks correctness)
        _channel.sink.add('${widget.playerId} answered: $_selectedAnswer');
      }
    
      @override
      Widget build(BuildContext context) {
        return Scaffold(
          appBar: AppBar(title: Text('Quiz - ${widget.playerId}')),
          body: _leaderboard.isNotEmpty
              ? Center(child: Text('Leaderboard: $_leaderboard'))
              : Column(
                  children: [
                    Text(_currentQuestion),
                    ..._options.map((option) => ListTile(
                          title: Text(option),
                          onTap: () => setState(() => _selectedAnswer = option),
                        )),
                    Text('Time left: $_remainingTime s'),
                  ],
                ),
        );
      }
    }
    

    Step 8: Main.dart (Entry Point) Modify lib/main.dart:

    import 'package:flutter/material.dart';
    import 'screens/host_screen.dart';
    import 'screens/player_screen.dart';
    
    void main() {
      runApp(MyApp());
    }
    
    class MyApp extends StatelessWidget {
      @override
      Widget build(BuildContext context) {
        return MaterialApp(
          title: 'Quiz Multiplayer',
          home: Builder(
            builder: (context) => Scaffold(
              body: Center(
                child: Column(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: [
                    ElevatedButton(
                      onPressed: () => Navigator.push(
                        context,
                        MaterialPageRoute(builder: (_) => HostScreen()),
                      ),
                      child: Text('Start as Host'),
                    ),
                    ElevatedButton(
                      onPressed: () => Navigator.push(
                        context,
                        MaterialPageRoute(builder: (_) => PlayerScreen(playerId: 'Player2')),
                      ),
                      child: Text('Join as Player 2'),
                    ),
                    ElevatedButton(
                      onPressed: () => Navigator.push(
                        context,
                        MaterialPageRoute(builder: (_) => PlayerScreen(playerId: 'Player3')),
                      ),
                      child: Text('Join as Player 3'),
                    ),
                  ],
                ),
              ),
            ),
          ),
        );
      }
    }
    

    How It Works:

    1. Host starts the server and waits for players.
    2. Players connect via WebSocket, sending "ready".
    3. Host broadcasts questions (60s timer).
    4. Players see questions, select answers (auto-submitted on timeout).
    5. After 12 questions, Host sends leaderboard.

    Run the App:

    1. Desktop (Host): flutter run -d macos (or windows/linux)
    2. Mobile (Players): flutter run -d android (replace IP in PlayerScreen with Host's IP)

    Notes:

    • Replace ws://localhost:8080 with your actual host IP for mobile players.
    • This is a simplified simulation. For production:
      • Use Firebase Realtime DB or Socket.IO for robust WebSockets.
      • Track player scores accurately.
      • Add error handling and retries.

    Now, run it, and you'll have a functional quiz multiplayer app! 🎉

    Final File Structure:

    quiz_multiplayer/
    ├── assets/
    │   └── questions.json
    ├── lib/
    │   ├── models/
    │   │   └── question.dart
    │   ├── services/
    │   │   ├── quiz_service.dart
    │   │   └── quiz_server.dart
    │   ├── screens/
    │   │   ├── host_screen.dart
    │   │   └── player_screen.dart
    │   └── main.dart
    ├── pubspec.yaml
    └── test/
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.