Lesson 16: Survive the Day – Python Detective

Part 1

Everything Comes Together

Over the past 15 lessons, you've built up an incredible set of tools. Variables, lists, dictionaries, functions, loops, conditionals, randomness, data analysis. Each one is powerful alone.

But the real magic happens when you combine them all.

Today, you're going to build the most ambitious project of the course: a Survive Middle School Simulator. It's a game where you navigate a school day making decisions — and every choice affects your stats, your relationships, and your ending.

This lesson is different from the others. Instead of learning new concepts one at a time, we're going to design and build a complete game, and I'll show you how every skill you've learned plays a role.

Part 2

Step 1: Decompose the Game (Lesson 1)

Every big project starts with decomposition — breaking it into parts. What does our game need?

Game Components

Player stats — energy, reputation, grades, friendship (Lesson 2: Abstraction — what matters?)

Scenes — morning, hallway, class, lunch, after school (Lesson 4: Categorization)

Choices — each scene offers 2-3 options (Lesson 3: Deductive Reasoning — rules for consequences)

Consequences — choices change stats (Lesson 10: Systems Thinking — pipelines)

Random events — surprise moments (Lesson 7: Inductive Reasoning)

Endings — different outcomes based on final stats (Lesson 9: Generalization)

Let's build each piece, then connect them.

Part 3

Step 2: The Player (Abstraction + Data Modeling)

A real student has thousands of attributes. We need to abstract — pick only what matters for our game:

def create_player(name):
    """Create a new player with starting stats."""
    return {
        "name": name,
        "energy": 10,
        "reputation": 5,
        "grades": 5,
        "friendship": 5,
        "choices_made": []
    }

def show_stats(player):
    """Display current player stats."""
    def bar(val, max_val=10):
        fill = int(val / max_val * 10)
        fill = max(0, min(10, fill))
        return "█" * fill + "░" * (10 - fill)
    
    print(f"\n  ╔═ {player['name'].upper()}'S STATS ═══════════╗")
    print(f"  ║ Energy:     {bar(player['energy'])} {player['energy']:>2d}/10 ║")
    print(f"  ║ Reputation: {bar(player['reputation'])} {player['reputation']:>2d}/10 ║")
    print(f"  ║ Grades:     {bar(player['grades'])} {player['grades']:>2d}/10 ║")
    print(f"  ║ Friendship: {bar(player['friendship'])} {player['friendship']:>2d}/10 ║")
    print(f"  ╚═══════════════════════════╝\n")

# Test it
player = create_player("Lena")
show_stats(player)

Dictionary for the player data (Lesson 12). Function to create the player (Lesson 8). Function to display stats with visual bars (Lessons 2 and 5). Everything we've learned is here.

Part 4

Step 3: The Choice Engine (Functions + Conditionals)

The core of our game: present a situation, let the player choose, and apply consequences. Let's build a general-purpose choice function:

def make_choice(player, situation, options):
    """Present a choice and apply consequences.
    
    options is a list of dictionaries:
    {"text": "Do this", "effects": {"energy": -2, "grades": +1}, "message": "You studied hard."}
    """
    print(f"\n{'─' * 40}")
    print(f"  {situation}")
    print(f"{'─' * 40}")
    
    for i, option in enumerate(options):
        print(f"  {i + 1}. {option['text']}")
    
    choice = input(f"\n  Your choice (1-{len(options)}): ")
    
    while not choice.isdigit() or int(choice) < 1 or int(choice) > len(options):
        choice = input(f"  Pick 1-{len(options)}: ")
    
    chosen = options[int(choice) - 1]
    
    # Apply effects
    for stat, change in chosen["effects"].items():
        player[stat] = player[stat] + change
        # Keep stats between 0 and 10
        player[stat] = max(0, min(10, player[stat]))
    
    player["choices_made"].append(chosen["text"])
    
    print(f"\n  → {chosen['message']}")
    return chosen

# Test it
player = {"name": "Lena", "energy": 10, "reputation": 5, "grades": 5, "friendship": 5, "choices_made": []}

make_choice(player, "Your alarm goes off. It's 6:30 AM.", [
    {"text": "Jump out of bed immediately", "effects": {"energy": -1}, "message": "Early bird! You have extra time."},
    {"text": "Hit snooze three times", "effects": {"energy": +1, "reputation": -1}, "message": "So cozy... but now you're rushing."},
    {"text": "Set a trap for your sibling instead", "effects": {"friendship": -1, "energy": 0}, "message": "Chaotic but entertaining."}
])

print(f"\nEnergy is now: {player['energy']}")

The Design

Each option is a dictionary with three keys: what it says, what it does to your stats, and a flavor message.

max(0, min(10, player[stat])) keeps stats between 0 and 10. min(10, x) caps at 10. max(0, x) floors at 0.

This is the generalization principle (Lesson 9): one function handles ANY choice, with ANY number of options, affecting ANY stats. We just change the data.

Part 5

Step 4: Building the Scenes

Now let's build the actual scenes of our school day. Each scene is a function that presents a situation and choices:

import random

def make_choice(player, situation, options):
    print(f"\n{'─' * 40}")
    print(f"  {situation}")
    print(f"{'─' * 40}")
    for i, opt in enumerate(options):
        print(f"  {i + 1}. {opt['text']}")
    choice = input(f"\n  Your choice (1-{len(options)}): ")
    while not choice.isdigit() or int(choice) < 1 or int(choice) > len(options):
        choice = input(f"  Pick 1-{len(options)}: ")
    chosen = options[int(choice) - 1]
    for stat, change in chosen["effects"].items():
        player[stat] = max(0, min(10, player[stat] + change))
    player["choices_made"].append(chosen["text"])
    print(f"\n  → {chosen['message']}")
    return chosen

def scene_morning(player):
    print("\n🌅 MORNING — 7:00 AM")
    make_choice(player, "Breakfast time. What do you eat?", [
        {"text": "A full breakfast (eggs, toast, juice)", "effects": {"energy": +2}, "message": "Fueled up and ready to go!"},
        {"text": "Grab a granola bar and run", "effects": {"energy": +1}, "message": "Quick but not very filling."},
        {"text": "Skip breakfast entirely", "effects": {"energy": -2}, "message": "Your stomach growls loudly on the bus..."}
    ])

def scene_hallway(player):
    print("\n🏫 HALLWAY — 8:15 AM")
    
    # Random event!
    if random.random() < 0.5:
        print("\n  ⚡ RANDOM EVENT: You find $5 on the ground!")
        make_choice(player, "What do you do with it?", [
            {"text": "Turn it in to the office", "effects": {"reputation": +2}, "message": "The secretary smiles. 'How honest!'"},
            {"text": "Keep it (finders keepers!)", "effects": {"reputation": -1}, "message": "A kid nearby looks suspicious..."},
        ])
    else:
        make_choice(player, "You see a kid struggling with a heavy backpack.", [
            {"text": "Help them carry their stuff", "effects": {"friendship": +2, "energy": -1}, "message": "They're so grateful! You made a friend."},
            {"text": "Walk past — you'll be late", "effects": {}, "message": "You make it to class on time."},
            {"text": "Make a joke about their backpack", "effects": {"reputation": -2, "friendship": -1}, "message": "Nobody laughed. Awkward silence."}
        ])

# Test two scenes
player = {"name": "Lena", "energy": 8, "reputation": 5, "grades": 5, "friendship": 5, "choices_made": []}

scene_morning(player)
scene_hallway(player)

print(f"\nAfter 2 scenes — Energy: {player['energy']}, Rep: {player['reputation']}, Friend: {player['friendship']}")

Notice how scene_hallway has a random event — 50% chance of finding money, 50% chance of the backpack situation. This uses random.random() which gives a decimal between 0 and 1. The game is different every time you play.

Part 6

Step 5: The Full Day

Let's add the remaining scenes and connect them into a complete game:

import random

# ═══════════════════════════════════════
# SURVIVE MIDDLE SCHOOL SIMULATOR
# ═══════════════════════════════════════

# === CORE ENGINE ===

def make_choice(player, situation, options):
    print(f"\n{'─' * 40}")
    print(f"  {situation}")
    print(f"{'─' * 40}")
    for i, opt in enumerate(options):
        print(f"  {i + 1}. {opt['text']}")
    choice = input(f"\n  Your choice (1-{len(options)}): ")
    while not choice.isdigit() or int(choice) < 1 or int(choice) > len(options):
        choice = input(f"  Pick 1-{len(options)}: ")
    chosen = options[int(choice) - 1]
    for stat, change in chosen["effects"].items():
        player[stat] = max(0, min(10, player[stat] + change))
    player["choices_made"].append(chosen["text"])
    print(f"\n  → {chosen['message']}")
    return chosen

def show_stats(player):
    def bar(val):
        v = max(0, min(10, val))
        return "█" * v + "░" * (10 - v)
    print(f"\n  ┌─ {player['name']}'s Stats ──────────┐")
    print(f"  │ ⚡ Energy:     {bar(player['energy'])} {player['energy']:>2d} │")
    print(f"  │ 🌟 Reputation: {bar(player['reputation'])} {player['reputation']:>2d} │")
    print(f"  │ 📚 Grades:     {bar(player['grades'])} {player['grades']:>2d} │")
    print(f"  │ 🤝 Friendship: {bar(player['friendship'])} {player['friendship']:>2d} │")
    print(f"  └───────────────────────────┘")

# === SCENES ===

def scene_morning(player):
    print("\n🌅 CHAPTER 1: MORNING")
    make_choice(player, "Your alarm goes off. It's way too early.", [
        {"text": "Get up and eat a real breakfast", "effects": {"energy": +2}, "message": "Eggs, toast, juice. You feel great."},
        {"text": "Snooze twice, grab a bar", "effects": {"energy": +1}, "message": "Cutting it close but you made it."},
        {"text": "Sleep through the alarm", "effects": {"energy": -1, "reputation": -1}, "message": "Mom is NOT happy. You rush out the door."}
    ])

def scene_hallway(player):
    print("\n🏫 CHAPTER 2: THE HALLWAY")
    
    events = [
        lambda: make_choice(player, "A kid drops their books everywhere.", [
            {"text": "Help pick them up", "effects": {"friendship": +2, "energy": -1}, "message": "They're super grateful. 'Thanks, you're the best!'"},
            {"text": "Step over the mess", "effects": {}, "message": "Not your problem. You keep walking."},
        ]),
        lambda: make_choice(player, "The popular kids invite you to hang out before class.", [
            {"text": "Join them", "effects": {"reputation": +2, "grades": -1}, "message": "Fun conversation! But you forgot to review your notes."},
            {"text": "Politely decline — you need to study", "effects": {"grades": +1}, "message": "Smart move. You feel prepared."},
        ]),
        lambda: make_choice(player, "You overhear someone spreading a rumor about a friend.", [
            {"text": "Defend your friend", "effects": {"friendship": +3, "reputation": +1, "energy": -1}, "message": "Your friend hears about it later. They're so thankful."},
            {"text": "Stay out of it", "effects": {}, "message": "You keep your head down. Probably wise."},
            {"text": "Listen in (it's kind of juicy...)", "effects": {"friendship": -2}, "message": "Your friend catches you listening. Yikes."}
        ])
    ]
    random.choice(events)()

def scene_class(player):
    print("\n📚 CHAPTER 3: CLASS TIME")
    make_choice(player, "The teacher asks a really hard question. Nobody raises their hand.", [
        {"text": "Raise your hand and try", "effects": {"grades": +2, "reputation": +1, "energy": -1}, "message": "You got it right! The teacher beams."},
        {"text": "Stay quiet and hope someone else answers", "effects": {}, "message": "Eventually the teacher just gives the answer."},
        {"text": "Whisper the answer to your friend to say", "effects": {"friendship": +1, "grades": +1}, "message": "Your friend looks like a genius. You're a good teammate."}
    ])

def scene_lunch(player):
    print("\n🍕 CHAPTER 4: LUNCH")
    
    make_choice(player, "Lunch time! Where do you sit?", [
        {"text": "With your usual friend group", "effects": {"friendship": +1}, "message": "Comfortable and fun. Classic lunch."},
        {"text": "At the table with the new kid", "effects": {"friendship": +2, "reputation": +1}, "message": "The new kid lights up. You made their whole week."},
        {"text": "Alone with your headphones", "effects": {"energy": +2, "friendship": -1}, "message": "Recharging your batteries. Sometimes you need that."}
    ])
    
    # Energy check
    if player["energy"] <= 2:
        print("\n  ⚠️ You're exhausted. Everything is harder now.")

def scene_afternoon(player):
    print("\n⏰ CHAPTER 5: AFTERNOON")
    
    # Different scenario based on current grades
    if player["grades"] >= 7:
        make_choice(player, "Your teacher pulls you aside: 'You're doing great! Want to enter the science fair?'", [
            {"text": "Yes! Sign me up!", "effects": {"grades": +2, "energy": -2}, "message": "Extra work but extra credit. Worth it!"},
            {"text": "Thanks, but I've got enough going on", "effects": {}, "message": "The teacher understands. No pressure."}
        ])
    else:
        make_choice(player, "You realize you have a test tomorrow you forgot about.", [
            {"text": "Start studying NOW", "effects": {"grades": +2, "energy": -2}, "message": "Panic studying, but at least you're trying."},
            {"text": "Ask a friend for their notes", "effects": {"grades": +1, "friendship": -1}, "message": "They share, but seem a bit annoyed."},
            {"text": "Wing it tomorrow", "effects": {"grades": -1}, "message": "Living dangerously. We'll see how that goes."}
        ])

def scene_afterschool(player):
    print("\n🚶 CHAPTER 6: AFTER SCHOOL")
    make_choice(player, "School's out! What do you do?", [
        {"text": "Go to the park with friends", "effects": {"friendship": +2, "energy": -1}, "message": "Great time! You played until sunset."},
        {"text": "Go home and do homework", "effects": {"grades": +2, "energy": -1}, "message": "Responsible choice. Tomorrow will be easier."},
        {"text": "Go home and play video games", "effects": {"energy": +2, "grades": -1}, "message": "So relaxing. But that homework isn't going anywhere..."},
        {"text": "Join a study group", "effects": {"grades": +1, "friendship": +1, "energy": -1}, "message": "Productive AND social. Best of both worlds."}
    ])

# === ENDING ===

def get_ending(player):
    total = player["energy"] + player["reputation"] + player["grades"] + player["friendship"]
    
    print("\n" + "═" * 40)
    print("  📋 END OF DAY REPORT")
    print("═" * 40)
    show_stats(player)
    
    print(f"  Total score: {total}/40")
    print()
    
    # Check for special endings
    if player["friendship"] >= 9:
        print("  🏆 THE SOCIAL BUTTERFLY")
        print("  Everyone loves you. You're the glue")
        print("  that holds your friend group together.")
    elif player["grades"] >= 9:
        print("  🏆 THE SCHOLAR")
        print("  Teachers can't stop praising you.")
        print("  College? You're basically already in.")
    elif player["reputation"] >= 9:
        print("  🏆 THE LEGEND")
        print("  Everyone knows your name. You're")
        print("  the talk of the school.")
    elif total >= 30:
        print("  🌟 THE BALANCED KID")
        print("  You handled everything well. Good grades,")
        print("  good friends, good vibes all around.")
    elif total >= 20:
        print("  👍 THE SURVIVOR")
        print("  Not perfect, but you made it through.")
        print("  Tomorrow's a fresh start!")
    elif player["energy"] <= 1:
        print("  😴 THE ZOMBIE")
        print("  You're running on empty. Straight to")
        print("  bed — don't even brush your teeth.")
    else:
        print("  🎲 THE WILDCARD")
        print("  What a chaotic day. Nobody — including")
        print("  you — knows what happened.")
    
    print()
    print("  Choices you made:")
    for i, choice in enumerate(player["choices_made"]):
        print(f"    {i+1}. {choice}")
    
    print("\n" + "═" * 40)
    print("  Play again for a different story!")
    print("═" * 40)

# === MAIN GAME ===

print("╔══════════════════════════════════╗")
print("║  SURVIVE MIDDLE SCHOOL          ║")
print("║  A Day Where Every Choice       ║")
print("║  Matters                         ║")
print("╚══════════════════════════════════╝")
print()

name = input("What's your name? ")
player = {
    "name": name,
    "energy": 8,
    "reputation": 5,
    "grades": 5,
    "friendship": 5,
    "choices_made": []
}

print(f"\nWelcome, {name}. You have one day.")
print("Every choice affects your stats.")
print("Try to survive with the best scores possible!")
show_stats(player)

# Play through each scene
scene_morning(player)
show_stats(player)

scene_hallway(player)

scene_class(player)
show_stats(player)

scene_lunch(player)

scene_afternoon(player)

scene_afterschool(player)

# Ending
get_ending(player)

Play it through! Then play again and make different choices — the story, the stats, and the ending will all change. Every playthrough is different because of the random events and your decisions.

Part 7

Every Skill in One Game

Let's count the skills this game uses:

The Full Toolkit

Lesson 1 — Decomposition: We broke the game into components: engine, scenes, stats, ending

Lesson 2 — Abstraction: We modeled a student with just 4 stats out of infinite possibilities

Lesson 3 — Deductive Reasoning: If/elif/else chains determine consequences and endings

Lesson 4 — Categorization: Choices organized as lists of dictionaries

Lesson 5 — Pattern Recognition: The choice→consequence→stats pattern repeats in every scene

Lesson 6 — Automation: One make_choice() function handles ALL choices

Lesson 7 — Inductive Reasoning: Random events make each playthrough different

Lesson 8 — Functions: Scenes are functions. Stats display is a function. Everything is organized

Lesson 9 — Generalization: make_choice() works for ANY situation with ANY options

Lesson 10 — Systems Thinking: Input → choices → stats → ending is a pipeline

Lesson 12 — Data Modeling: Player is a dictionary. Options are dicts. The game is structured data

Lesson 13 — Debugging: If something breaks, you know how to find and fix it!

Every single concept from the course appears in this game. You didn't just learn isolated skills — you built a toolkit that works together.

Part 8

Making It Your Own

The game above is a foundation. Here's how to extend it — each modification uses skills you already have:

# IDEA 1: Add an inventory system (Lesson 12: dictionaries)
inventory = {"snacks": 1, "phone_charged": True, "homework_done": False}

# IDEA 2: Add a "time" system (Lesson 5: patterns)
time_of_day = 7  # starts at 7 AM
# Each scene advances time by 1-2 hours

# IDEA 3: Add NPC relationships (Lesson 12: nested dicts)
npcs = {
    "bestfriend": {"name": "Zoe", "trust": 8, "mood": "happy"},
    "rival": {"name": "Oliver", "trust": 2, "mood": "jealous"},
    "teacher": {"name": "Ms. Chen", "trust": 5, "mood": "neutral"}
}

# IDEA 4: Conditional scenes (Lesson 3: deductive reasoning)
# If reputation > 7, you get invited to a special event
# If energy < 3, you can't do sports after school

# IDEA 5: Track stats over time (Lesson 14: patterns)
# Save energy at each checkpoint and show a chart at the end

print("EXPANSION IDEAS:")
print("═" * 35)
print("  1. Inventory system")
print("  2. Time tracking")
print("  3. NPC relationships")
print("  4. Conditional scenes")
print("  5. Stat history charts")
print()
print("Each one uses skills you already have!")
print("Pick one and add it to the game.")

Part 9

What You Just Did

You built a complex, interactive game with multiple scenes, branching choices, stat tracking, random events, and multiple endings. And you did it by combining skills you've been learning one by one over 15 lessons.

This is how real software gets built. Not by knowing everything at once, but by knowing many small things and putting them together. A web app is just functions, data, and logic — organized well.

The Big Idea

Complex things are made of simple parts. You don't need to learn something "advanced" to build something impressive — you need to get good at combining the basics. The kid who knows variables, functions, loops, and dictionaries really well can build almost anything.

Thinking Questions

Which thinking skill (decomposition, abstraction, etc.) did you use the most while building or playing this game?
If you could add one more scene to the game, what would it be? What choices would you offer?
How is building a game similar to solving any big problem? (Hint: break it down, build the pieces, connect them.)

Challenges

Level Up

Challenge 1 · Add Two Scenes

Write two new scene functions (maybe "gym class" and "bus ride home") with at least 3 choices each. Add them to the game flow. Make sure the choices affect stats in interesting ways.

Challenge 2 · More Endings

Add at least 3 more possible endings. Ideas: "The Class Clown" (high friendship, low grades), "The Mystery" (all stats exactly 5), "The Overachiever" (everything above 7). Make the ending messages fun and specific.

Challenge 3 · Two-Day Version

Make the game span two days. After Day 1, show a "night" scene where the player can rest (restore energy) or study late (boost grades but lose energy). Then Day 2's scenes should reference choices from Day 1. Use the choices_made list to check what happened earlier.

Summary

What You Learned

Thinking Skill

Synthesis & Integration — combining multiple thinking skills and coding techniques to create something complex. The whole is greater than the sum of its parts.

Game Architecture

Player model — dictionary with stats

Choice engine — one general function for all decisions

Scene functions — each scene is self-contained

Random events — different experiences each playthrough

Conditional content — scenes adapt based on current stats

Multiple endings — final state determines the story

Stat clamping — max(0, min(10, value)) keeps numbers in range

← Lesson 15 Lesson 17 →

Survive the Day: Your First Real Game (Where Every Choice Matters)