🏗️ Lesson 6.1: Classes and Objects

# Data — just a dictionary
player = {"name": "Alice", "health": 100, "inventory": []}

# Functions that operate on that data
def take_damage(player, amount):
    player["health"] -= amount
    if player["health"] < 0:
        player["health"] = 0

def add_item(player, item):
    player["inventory"].append(item)

take_damage(player, 30)
add_item(player, "sword")
print(f"{player['name']}: {player['health']} HP")  # Alice: 70 HP

// Data — just an object
let player = { name: "Alice", health: 100, inventory: [] };

// Functions that operate on that data
function takeDamage(player, amount) {
    player.health -= amount;
    if (player.health < 0) player.health = 0;
}

function addItem(player, item) {
    player.inventory.push(item);
}

takeDamage(player, 30);
addItem(player, "sword");
console.log(`${player.name}: ${player.health} HP`);  // Alice: 70 HP

// Without OOP, C# would use static methods + arrays/dicts
// But C# is built for OOP — this is the "fighting the language" way

// You'd have to use dictionaries or parallel arrays
// and pass them into every function. It gets messy fast.

# Define the class
class Player:
    pass  # Empty class (placeholder)

# Create objects (instances)
player1 = Player()
player2 = Player()

# They're separate objects
print(player1)         # <__main__.Player object at 0x...>
print(player1 == player2)  # False — different objects!
print(type(player1))   # <class '__main__.Player'>

// Define the class
class Player {
    // Empty class (placeholder)
}

// Create objects (instances)
let player1 = new Player();
let player2 = new Player();

// They're separate objects
console.log(player1);              // Player {}
console.log(player1 === player2);  // false — different objects!
console.log(typeof player1);       // "object"
console.log(player1 instanceof Player);  // true

// Define the class
class Player
{
    // Empty class (placeholder)
}

// Create objects (instances)
Player player1 = new Player();
Player player2 = new Player();

// They're separate objects
Console.WriteLine(player1);                    // Player
Console.WriteLine(player1 == player2);         // False
Console.WriteLine(player1.GetType().Name);     // Player

class Player:
    def __init__(self, name, health=100):
        self.name = name          # Instance attribute
        self.health = health      # Instance attribute with default
        self.inventory = []       # Always starts empty

# Create players
player1 = Player("Alice")
player2 = Player("Bob", 85)

print(player1.name)       # Alice
print(player1.health)     # 100
print(player2.health)     # 85
print(player1.inventory)  # []

class Player {
    constructor(name, health = 100) {
        this.name = name;          // Instance property
        this.health = health;      // Instance property with default
        this.inventory = [];       // Always starts empty
    }
}

// Create players
let player1 = new Player("Alice");
let player2 = new Player("Bob", 85);

console.log(player1.name);       // Alice
console.log(player1.health);     // 100
console.log(player2.health);     // 85
console.log(player1.inventory);  // []

class Player
{
    public string Name;
    public int Health;
    public List<string> Inventory;

    // Constructor — same name as the class
    public Player(string name, int health = 100)
    {
        Name = name;
        Health = health;
        Inventory = new List<string>();
    }
}

// Create players
Player player1 = new Player("Alice");
Player player2 = new Player("Bob", 85);

Console.WriteLine(player1.Name);       // Alice
Console.WriteLine(player1.Health);     // 100
Console.WriteLine(player2.Health);     // 85
Console.WriteLine(player1.Inventory.Count);  // 0

class Player:
    def __init__(self, name, health=100):
        self.name = name
        self.health = health
        self.inventory = []

    def take_damage(self, amount):
        self.health -= amount
        if self.health < 0:
            self.health = 0
        print(f"{self.name} takes {amount} damage! HP: {self.health}")

    def heal(self, amount):
        self.health += amount
        if self.health > 100:
            self.health = 100
        print(f"{self.name} heals {amount}! HP: {self.health}")

    def add_item(self, item):
        self.inventory.append(item)
        print(f"{self.name} picked up {item}")

    def show_status(self):
        items = ", ".join(self.inventory) if self.inventory else "empty"
        print(f"{self.name} | HP: {self.health} | Items: {items}")

# Use it
hero = Player("Alice")
hero.add_item("sword")
hero.add_item("potion")
hero.take_damage(35)
hero.heal(20)
hero.show_status()
# Alice | HP: 85 | Items: sword, potion

class Player {
    constructor(name, health = 100) {
        this.name = name;
        this.health = health;
        this.inventory = [];
    }

    takeDamage(amount) {
        this.health -= amount;
        if (this.health < 0) this.health = 0;
        console.log(`${this.name} takes ${amount} damage! HP: ${this.health}`);
    }

    heal(amount) {
        this.health += amount;
        if (this.health > 100) this.health = 100;
        console.log(`${this.name} heals ${amount}! HP: ${this.health}`);
    }

    addItem(item) {
        this.inventory.push(item);
        console.log(`${this.name} picked up ${item}`);
    }

    showStatus() {
        let items = this.inventory.length ? this.inventory.join(", ") : "empty";
        console.log(`${this.name} | HP: ${this.health} | Items: ${items}`);
    }
}

// Use it
let hero = new Player("Alice");
hero.addItem("sword");
hero.addItem("potion");
hero.takeDamage(35);
hero.heal(20);
hero.showStatus();
// Alice | HP: 85 | Items: sword, potion

class Player
{
    public string Name;
    public int Health;
    public List<string> Inventory;

    public Player(string name, int health = 100)
    {
        Name = name;
        Health = health;
        Inventory = new List<string>();
    }

    public void TakeDamage(int amount)
    {
        Health -= amount;
        if (Health < 0) Health = 0;
        Console.WriteLine($"{Name} takes {amount} damage! HP: {Health}");
    }

    public void Heal(int amount)
    {
        Health += amount;
        if (Health > 100) Health = 100;
        Console.WriteLine($"{Name} heals {amount}! HP: {Health}");
    }

    public void AddItem(string item)
    {
        Inventory.Add(item);
        Console.WriteLine($"{Name} picked up {item}");
    }

    public void ShowStatus()
    {
        string items = Inventory.Count > 0
            ? string.Join(", ", Inventory) : "empty";
        Console.WriteLine($"{Name} | HP: {Health} | Items: {items}");
    }
}

// Use it
Player hero = new Player("Alice");
hero.AddItem("sword");
hero.AddItem("potion");
hero.TakeDamage(35);
hero.Heal(20);
hero.ShowStatus();
// Alice | HP: 85 | Items: sword, potion

class Dog:
    def __init__(self, name):
        self.name = name    # self = the object being created

    def bark(self):
        # self = the object calling this method
        print(f"{self.name} says Woof!")

fido = Dog("Fido")
rex = Dog("Rex")

fido.bark()   # "Fido says Woof!"  — self is fido
rex.bark()    # "Rex says Woof!"   — self is rex

# What Python actually does behind the scenes:
# fido.bark()  →  Dog.bark(fido)
# rex.bark()   →  Dog.bark(rex)

class Dog {
    constructor(name) {
        this.name = name;    // this = the object being created
    }

    bark() {
        // this = the object calling this method
        console.log(`${this.name} says Woof!`);
    }
}

let fido = new Dog("Fido");
let rex = new Dog("Rex");

fido.bark();   // "Fido says Woof!"  — this is fido
rex.bark();    // "Rex says Woof!"   — this is rex

// Note: 'this' in JavaScript can be tricky in callbacks
// (we'll cover that in Lesson 17)

class Dog
{
    public string Name;

    public Dog(string name)
    {
        Name = name;   // 'this' is implicit
        // this.Name = name;  ← also valid, but not needed here
    }

    public void Bark()
    {
        // 'this' is the object calling the method
        Console.WriteLine($"{Name} says Woof!");
        // Console.WriteLine($"{this.Name} says Woof!");  ← same thing
    }
}

Dog fido = new Dog("Fido");
Dog rex = new Dog("Rex");

fido.Bark();   // "Fido says Woof!"  — this is fido
rex.Bark();    // "Rex says Woof!"   — this is rex

class Player:
    def __init__(self, name, health=100):
        self.name = name
        self.health = health
        self.inventory = []

    def add_item(self, item):
        self.inventory.append(item)

    def show_status(self):
        items = ", ".join(self.inventory) if self.inventory else "empty"
        print(f"{self.name} | HP: {self.health} | Items: {items}")

# Create three independent players
alice = Player("Alice")
bob = Player("Bob", 85)
charlie = Player("Charlie")

# Each has their OWN data
alice.add_item("sword")
bob.add_item("shield")
bob.add_item("potion")
charlie.add_item("bow")

alice.show_status()    # Alice | HP: 100 | Items: sword
bob.show_status()      # Bob | HP: 85 | Items: shield, potion
charlie.show_status()  # Charlie | HP: 100 | Items: bow

# Modifying one doesn't affect the others!
alice.health = 50
print(bob.health)  # 85 — unchanged

class Player {
    constructor(name, health = 100) {
        this.name = name;
        this.health = health;
        this.inventory = [];
    }

    addItem(item) { this.inventory.push(item); }

    showStatus() {
        let items = this.inventory.length ? this.inventory.join(", ") : "empty";
        console.log(`${this.name} | HP: ${this.health} | Items: ${items}`);
    }
}

// Create three independent players
let alice = new Player("Alice");
let bob = new Player("Bob", 85);
let charlie = new Player("Charlie");

// Each has their OWN data
alice.addItem("sword");
bob.addItem("shield");
bob.addItem("potion");
charlie.addItem("bow");

alice.showStatus();    // Alice | HP: 100 | Items: sword
bob.showStatus();      // Bob | HP: 85 | Items: shield, potion
charlie.showStatus();  // Charlie | HP: 100 | Items: bow

// Modifying one doesn't affect the others!
alice.health = 50;
console.log(bob.health);  // 85 — unchanged

class Player
{
    public string Name;
    public int Health;
    public List<string> Inventory;

    public Player(string name, int health = 100)
    {
        Name = name;
        Health = health;
        Inventory = new List<string>();
    }

    public void AddItem(string item) => Inventory.Add(item);

    public void ShowStatus()
    {
        string items = Inventory.Count > 0
            ? string.Join(", ", Inventory) : "empty";
        Console.WriteLine($"{Name} | HP: {Health} | Items: {items}");
    }
}

// Create three independent players
Player alice = new Player("Alice");
Player bob = new Player("Bob", 85);
Player charlie = new Player("Charlie");

// Each has their OWN data
alice.AddItem("sword");
bob.AddItem("shield");
bob.AddItem("potion");
charlie.AddItem("bow");

alice.ShowStatus();    // Alice | HP: 100 | Items: sword
bob.ShowStatus();      // Bob | HP: 85 | Items: shield, potion
charlie.ShowStatus();  // Charlie | HP: 100 | Items: bow

// Modifying one doesn't affect the others!
alice.Health = 50;
Console.WriteLine(bob.Health);  // 85 — unchanged

class Player:
    def __init__(self, name, health=100):
        self.name = name
        self.health = health
        self.inventory = []

    def is_alive(self):
        return self.health > 0

    def show_status(self):
        status = "alive" if self.is_alive() else "defeated"
        print(f"  {self.name}: {self.health} HP ({status})")

# Create a party of adventurers
party = [
    Player("Alice", 100),
    Player("Bob", 45),
    Player("Charlie", 0),
    Player("Diana", 78)
]

# Loop over objects
print("=== Party Status ===")
for player in party:
    player.show_status()

# Filter: who's still alive?
alive = [p for p in party if p.is_alive()]
print(f"\nSurvivors: {[p.name for p in alive]}")
# Survivors: ['Alice', 'Bob', 'Diana']

# Find: who has the lowest health (among the living)?
weakest = min(alive, key=lambda p: p.health)
print(f"Needs healing: {weakest.name} ({weakest.health} HP)")
# Needs healing: Bob (45 HP)

# Total party health
total_hp = sum(p.health for p in party)
print(f"Total party HP: {total_hp}")  # 223

class Player {
    constructor(name, health = 100) {
        this.name = name;
        this.health = health;
        this.inventory = [];
    }

    isAlive() { return this.health > 0; }

    showStatus() {
        let status = this.isAlive() ? "alive" : "defeated";
        console.log(`  ${this.name}: ${this.health} HP (${status})`);
    }
}

// Create a party of adventurers
let party = [
    new Player("Alice", 100),
    new Player("Bob", 45),
    new Player("Charlie", 0),
    new Player("Diana", 78)
];

// Loop over objects
console.log("=== Party Status ===");
party.forEach(p => p.showStatus());

// Filter: who's still alive?
let alive = party.filter(p => p.isAlive());
console.log(`\nSurvivors: ${alive.map(p => p.name)}`);

// Find: lowest health among the living
let weakest = alive.reduce((min, p) => p.health < min.health ? p : min);
console.log(`Needs healing: ${weakest.name} (${weakest.health} HP)`);

// Total party health
let totalHP = party.reduce((sum, p) => sum + p.health, 0);
console.log(`Total party HP: ${totalHP}`);  // 223

class Player
{
    public string Name;
    public int Health;

    public Player(string name, int health = 100)
    {
        Name = name;
        Health = health;
    }

    public bool IsAlive() => Health > 0;

    public void ShowStatus()
    {
        string status = IsAlive() ? "alive" : "defeated";
        Console.WriteLine($"  {Name}: {Health} HP ({status})");
    }
}

// Create a party of adventurers
var party = new List<Player>
{
    new Player("Alice", 100),
    new Player("Bob", 45),
    new Player("Charlie", 0),
    new Player("Diana", 78)
};

// Loop over objects
Console.WriteLine("=== Party Status ===");
party.ForEach(p => p.ShowStatus());

// Filter: who's still alive?
var alive = party.Where(p => p.IsAlive()).ToList();
Console.WriteLine($"\nSurvivors: {string.Join(", ", alive.Select(p => p.Name))}");

// Find: lowest health among the living
var weakest = alive.OrderBy(p => p.Health).First();
Console.WriteLine($"Needs healing: {weakest.Name} ({weakest.Health} HP)");

// Total party health
int totalHP = party.Sum(p => p.Health);
Console.WriteLine($"Total party HP: {totalHP}");  // 223