Demo Mode

BBP Project 4: My Quiz Game

:information_source: Project Overview Difficulty: ⭐⭐⭐⭐ (4 out of 5 stars)
Time to Complete: 60-75 minutes
Skills Practiced:

Lists and list operations

Loops (for loops and nested loops)

User input and validation

Data visualization with Pygal

Conditional statements

Score tracking and management

What You'll Build: :dart: Create an interactive quiz game where multiple players compete! You'll build a smart quiz system that tracks scores for each player and displays the results in a colorful graph. Perfect for testing your friends' knowledge on any topic you choose!

:emoji:️ Project Roadmap

vbnet

Step 1: Setup & Import → Step 2: Create Quiz Questions → Step 3: Build Game Logic → Step 4: Add Scoring → Step 5: Visualize Results → Success! 🎉

Activity Instruction: Create a new project

Setup Instructions:

Go to EduBlocks page and login with your Google account: https://app.edublocks.org/login

Everytime you want to start a new project, click on the "Editor" icon. To resume your project, click on the "Projects" icon.

Setup:

Select the Python 3 mode
Give the project a filename called: My Quiz Game
Click on the "Start Coding" button and then "Save" at the top-right

:bulb: Save Your Progress!

Make sure you have the habit of saving once in a while to avoid losing progress. Click the "Save" button every 5-10 minutes or after completing each major step!

Project Guideline (Basic)

Let's create a quiz with 2 participants. At the end of the quiz, the program will create a graph that shows all the scores of the participants.

The quiz uses list variables to keep track of questions and answers.

Here is an example of the quiz question and answer:

Question: "What's my favourite colour?"
Answer: "Yellow"

:bulb: Pro Tip for Lists

Think of lists like containers that hold multiple items in order:

questions = ["Question 1?", "Question 2?", "Question 3?"]

answers = ["Answer 1", "Answer 2", "Answer 3"]

The first question (questions[0]) matches with the first answer (answers[0])!

Rules:

You have to use list variables to store questions and answers, but they don't have to be in 1 list only
You must use loops code to loop through all the questions
You must keep track of each player's name and scores
You need to have at least 2 questions. Each question just needs to have 1 answer

:warning: Common Pitfall Alert! Case Sensitivity: Remember that "Yellow" and "yellow" are different in Python! Make sure your answers match exactly, or consider using .lower() to make answers case-insensitive.

:white_check_mark: Milestone Checkpoint 1

Before moving forward, make sure you have:

Created two list variables (one for questions, one for answers)
Added at least 2 quiz questions
Set up variables to store player names
Initialized score variables to 0

Programming Instructions

One. Import required modules:

Import modules needed for creating graphs (Pygal)

:bulb: Block Connection to Python

In EduBlocks, when you drag the "import pygal" block, it creates the Python code: import pygal. This lets us use Pygal's graphing powers!

2. Setup quiz data:

Create list variables for questions and answers
Set up participant tracking system

Example structure:

ini

questions = ["What's 2+2?", "What color is the sky?"]
answers = ["4", "blue"]

3. Quiz logic implementation:

Use loops to iterate through questions
Track scores for each participant
Handle user input and answer checking

:bulb: Best Practice

Use a for loop with range(len(questions)) to go through all questions. This connects the question index with the answer index automatically!

In EduBlocks, this looks like:

Drag a for i in range() block

Inside range, put a len() block

Inside len, put your questions variable

This creates the Python code: for i in range(len(questions)):

4. Score visualization:

Create a graph showing participant scores
Display final results

:white_check_mark: Milestone Checkpoint 2

After implementing the basic quiz:

Both players can answer all questions
Scores are tracked correctly
The graph displays at the end
Player names appear on the graph

Advanced Version

For the advanced version of the project, you must create the program so that you can let the user decide how many participants are joining the quiz.

:warning: Challenge Ahead! This advanced version requires nested loops and dynamic list management. Take your time and test each part as you build it!

Setup for Advanced:

Select the Python 3 mode
Give the project a filename called: My Quiz Game (Advanced)
Click on the "Start Coding" button and then "Save" at the top-right

Advanced Rules:

Even though users can set multiple participants, the program must limit to a range of 2 to 5 participants
You cannot hardcode the participants with multiple variables but rather, you should use lists and loops

Tips:

You can use different variable names to represent the i as the loop index. This is useful when you have nested loops and you want to reference the loop index.

:bulb: Nested Loop Variables

Instead of using 'i' for all loops, try:

Outer loop: for player_index in range(num_players)

Inner loop: for question_index in range(len(questions))

This makes your code much easier to understand!

Programming Instructions for Advanced

One. Dynamic participant setup:

Ask user for number of participants (2-5 range validation)
Use lists to store participant names and scores
Implement input validation for participant count

:warning: Input Validation Use a while loop to keep asking until you get a valid number (2-5). This prevents your program from crashing with invalid input!

2. Enhanced quiz logic:

Use nested loops for multiple participants
Dynamic score tracking using list indexing
Participant management through loops instead of hardcoded variables

Example structure:

scss

player_names = []
player_scores = []
for i in range(num_players):
    name = input("Enter player name: ")
    player_names.append(name)
    player_scores.append(0)

3. Advanced score visualization:

Generate graph with variable number of participants
Display comprehensive results for all participants

:white_check_mark: Milestone Checkpoint 3

For the advanced version:

User can choose 2-5 players
Invalid inputs are handled properly
All players stored in lists (not separate variables)
Each player gets to answer all questions
Final graph shows all player scores

:bug: Debugging Tips for EduBlocks

Having trouble? Here are common issues and solutions specific to EduBlocks:

One. Graph not showing?

:white_check_mark: Make sure the import pygal block is at the very top
:white_check_mark: Check that you called .render_in_browser() at the end
:white_check_mark: Save your file before running (Ctrl+S or Cmd+S)
:white_check_mark: If using school computers, check if pop-ups are blocked

2. Scores not updating?

:white_check_mark: Verify you're using the correct list index for each player
:white_check_mark: Use score = score + 1 or score += 1 blocks
:white_check_mark: Add print blocks after scoring to see values: print("Player 1 score:", score1)

3. Loop errors in EduBlocks?

:white_check_mark: Make sure your loop variable block color matches (purple for numbers)
:white_check_mark: Check that blocks are properly nested (indented) inside the loop
:white_check_mark: For range(len(questions)), make sure questions list exists first
:white_check_mark: Can't find the right block? Use the search box!

4. Input validation not working?

:white_check_mark: Use the int() block to convert text input to numbers
:white_check_mark: For while loops, make sure condition blocks are connected properly
:white_check_mark: Test with edge cases: What if someone types "hello" instead of a number?

:warning: EduBlocks-Specific Tips

Red outline on blocks = Error! Hover over to see why

Blocks won't connect? = Check if they're compatible types

Code looks right but won't run? = Check for disconnected blocks

Can't drag blocks? = Make sure you're in edit mode, not preview

Required Elements

Make sure your My Quiz Game project includes:

Basic Version: 2 participants, list variables for questions/answers, score tracking
Loop implementation: Iterate through questions using loops
Score visualization: Graph showing participant scores
At least 2 questions: Each with single correct answer
Advanced Version: User-defined participants (2-5), list-based participant management
Input validation: Ensure participant count within allowed range
Dynamic loops: Handle variable number of participants without hardcoding
Proper use of nested loops with different index variables

:star2: Make It Your Own!

Once your quiz is working, try these personalization ideas:

Easy Enhancements:

Theme your quiz: Make it about your favorite movie, book, or hobby
Add more questions: Try 5 or even 10 questions
Custom messages: Add congratulations for high scores
Color coding: Make the graph bars different colors

Medium Challenges:

Question categories: Group questions by topic
Difficulty levels: Award more points for harder questions
Time limits: Use the time module to add a countdown
Leaderboard: Keep track of all-time high scores

Advanced Features:

Multiple choice: Give 4 options instead of open answers
Random questions: Use the random module to shuffle questions
Save results: Write scores to a file for later viewing
Tournament mode: Multiple rounds with eliminations

:bulb: Python Connection

Each enhancement teaches real programming concepts:

Categories = Dictionary data structures

Time limits = Working with the time module

File saving = File I/O operations

Random questions = List shuffling algorithms

Project Submission

When you have completed your "My Quiz Game" project, submit it using the link below: Submit Your Project Here

:warning: Before You Submit! Test your program thoroughly:

Run the quiz with 2 players first

Try entering wrong number of players (1, 6, "abc")

Check if scores are calculated correctly

Make sure the graph displays properly

Test with different answers (correct and incorrect)

Note: You need to submit 1 project link for this project - the advanced version which incorporates all the concepts from the basic version.

:tada: Great job creating your quiz game! You've learned how to work with lists, loops, user input, and data visualization - all essential programming skills!