Digital Pet Simulator

A digital pet does not “feel.”

It evolves.

Hunger changes. Energy changes. Mood changes.

Every action modifies state.

And state determines behavior.

This project trains something critical:

Systems are not events.
Systems are evolving state.

Watch First - Understanding State Evolution

While watching, think about:

• What defines the pet at any moment?
• What transitions are allowed?
• What values must be bounded?
• What causes state to change?

Now let’s define it clearly.

What You Are Building

You will design a console-based digital pet system with:

State variables:

• hunger
• energy
• mood

User actions:

• Feed
• Play
• Rest
• Check status
• Exit

Rules:

• Hunger increases over time
• Playing reduces energy
• Low energy forces rest
• High hunger decreases mood
• Values must stay within limits

We are not building graphics.

We are modeling behavior.

Define the State Clearly

Let’s define safe boundaries:

• hunger: 0 to 10
• energy: 0 to 10
• mood: 0 to 10

Values must never:

• Go negative
• Exceed max
• Become inconsistent

This is state discipline.

Think Before Coding

Ask:

• What happens if hunger reaches 10?
• What happens if energy reaches 0?
• Can mood become negative?
• What happens if user keeps playing?
• When does simulation end?

Systems must guard themselves.

Simple Version - Direct State Mutation

Let’s start simple.

hunger = 5
energy = 5
mood = 5

while True:
    print("\nHunger:", hunger, "Energy:", energy, "Mood:", mood)
    print("1. Feed")
    print("2. Play")
    print("3. Rest")
    print("4. Exit")

    choice = input("Choose action: ")

    if choice == "1":
        hunger -= 2
        mood += 1
        print("You fed the pet.")

    elif choice == "2":
        energy -= 2
        mood += 2
        hunger += 1
        print("You played with the pet.")

    elif choice == "3":
        energy += 3
        hunger += 1
        print("The pet rested.")

    elif choice == "4":
        break

    else:
        print("Invalid choice.")

    # Boundaries
    hunger = max(0, min(hunger, 10))
    energy = max(0, min(energy, 10))
    mood = max(0, min(mood, 10))

This works.

But it lacks behavioral logic.

Improve It - Add Automatic Consequences

Now we add rule-based behavior.

    if hunger >= 8:
        mood -= 2
        print("Pet is very hungry!")

    if energy <= 2:
        print("Pet is too tired to play.")

    if hunger == 10:
        print("Pet is starving!")

Now the system responds automatically.

State drives consequence.

This is evolution.

Make It Cleaner - Separate Logic

Instead of mixing everything in loop, separate behavior.

def apply_rules(hunger, energy, mood):
    if hunger >= 8:
        mood -= 2
    if energy <= 2:
        mood -= 1

    hunger = max(0, min(hunger, 10))
    energy = max(0, min(energy, 10))
    mood = max(0, min(mood, 10))

    return hunger, energy, mood

Now main loop becomes cleaner.

Structure improves.

Systems become readable.

What This Trains

You are learning:

• State modeling
• Controlled mutation
• Sequential transitions
• Defensive boundaries
• Separation of logic

This is foundational system thinking.

Edge Cases That Break Systems

Test scenarios:

• Play when energy is 0
• Feed when hunger is 0
• Rest repeatedly
• No actions for long time

Ask:

• Should automatic decay happen?
• Should pet “die”?
• Should simulation terminate?

Edge-case thinking strengthens systems.

Growth Reflection

Right now:

• One pet
• One user
• Simple loop

Now imagine:

1,000 pets.

Multiple users.

Time-based evolution.

Persistent storage.

Suddenly:

• Concurrency matters
• Memory matters
• Architecture matters

But the foundation remains:

State + transitions.

Interview Extension

Enhance system to:

• Add age variable
• Add random events
• Add happiness decay over time
• Add win/loss condition
• Add scoring system
• Track action history

Each enhancement tests structural clarity.

Engineering Reflection

Digital pet is simple.

But it forces discipline:

• State must stay valid
• Rules must be predictable
• Transitions must be safe

Almost every real system is:

State + Rules + Transitions

Login systems. Banking systems. Game engines. AI training loops.

This project is not a toy.

It is a simplified state machine.

Final Thought

If you can model evolving state cleanly,

You are learning to design living systems.

And all complex software behaves like something alive:

Changing. Reacting. Evolving.