📓 Lekcja 01 — Obiekt i stan

📍 Gdzie jesteśmy?

Mamy już świat który liczy czas. Czas na pierwszy obiekt.

🔄 Co nowego w tej lekcji

Jedna nowość: obiekt istnieje w przestrzeni. Ma pozycję. Można go ruszyć i zobaczyć.

⚠️ Zanim zaczniesz

Potrzebujesz z L00:

• Rozumiesz czym jest class i konstruktor __init__
• Wiesz czym jest self.atrybut
• Masz zainstalowane matplotlib i jupyter

Jeśli nie — wróć do L00, sekcja Instalacja środowiska.

🎯 Cel lekcji

Po tej lekcji:

• ✅ istnieje obiekt w przestrzeni 2D
• ✅ obiekt ma stan (x, y)
• ✅ potrafimy zmienić stan (ruch)
• ✅ potrafimy to zobaczyć (wizualizacja)
• ✅ obiekt pamięta historię pozycji

Nadal nie mamy:

• ❌ grawitacji ani fizyki
• ❌ kolizji
• ❌ świata który wpływa na obiekt
• ❌ prędkości (to dopiero L02)

To jest czysta kinematyka — i bardzo dobrze.

🏛️ Anegdota historyczna

Kartezjusz i punkt w przestrzeni

W 1637 roku René Descartes opublikował La Géométrie — dodatek do słynnego Rozprawy o metodzie. Opisał w nim pomysł który dziś wydaje się oczywisty: każdy punkt w przestrzeni można opisać parą liczb (x, y).

Legenda mówi, że pomysł przyszedł mu do głowy gdy leżał w łóżku i obserwował muchę chodzącą po suficie. Uświadomił sobie, że może opisać dokładne położenie muchy podając odległość od dwóch ścian. Reszta to historia — układ współrzędnych który dziś nosi jego imię (kartezjański).

W naszej symulacji robimy dokładnie to samo: self.x i self.y to odległości od punktu (0, 0). Każdy obiekt w symulacji to punkt kartezjański — opisany dwiema liczbami.

🧠 Ironia: Descartes opisał muchę parą liczb w XVII wieku.
My opisujemy pocisk parą liczb w XXI wieku.
Matematyka się nie zmieniła.

🧱 Pojęcie nr 1 — stan obiektu

💡 Dla nowicjusza

Stan to komplet informacji opisujących obiekt w danej chwili.

Analogie:

• 📍 adres — mówi gdzie jesteś, nie jak tam dotarłeś
• 🌡️ temperatura — opis teraz, nie historia
• 💳 saldo konta — aktualny stan, nie historia transakcji

W naszej symulacji minimalny stan to:

self.x = 0.0  # pozycja pozioma
self.y = 0.0  # pozycja pionowa

I NIC WIĘCEJ. Nie ma prędkości, nie ma masy, nie ma czasu. Tylko: gdzie obiekt jest teraz.

🧱 Zasada Profesora: Zaczynamy od najmniejszego sensownego stanu. Resztę dołożymy później.

🧱 Pojęcie nr 2 — class Object

Tak jak World był klasą — obiekt też jest klasą. Dlaczego?

• ma swoje dane (x, y)
• ma zachowanie (można go ruszyć)
• będzie się zmieniał w czasie

💡 Dla nowicjusza

World = zegarek świata — tyka i liczy czas
Object = coś w tym świecie — ma pozycję, można je ruszyć

Oba są klasami bo oba mają stan i zachowanie.

🔍 Jak działa ten kod — linia po linii

class Object:

Nowy typ danych — obiekt symulacji. Od tej chwili Python wie co to Object.

def __init__(self, x, y):

Konstruktor — uruchamia się automatycznie gdy piszesz Object(x=0.0, y=0.0). Dostaje dwa argumenty: x i y — początkową pozycję.

self.x = x  # pozycja pozioma
self.y = y  # pozycja pionowa

Zapisujemy stan w obiekcie. self.x to atrybut — własna zmienna tego konkretnego obiektu. To jest cały stan obiektu w tej lekcji. Tylko dwie liczby.

❓ Częste błędy

🧪 Tworzymy obiekt

▶️ Oczekiwany wynik

Obiekt istnieje. Nie rusza się. Nie wie że istnieje świat. Ale ma stan.

🔍 Jak działa ten kod

obj = Object(x=0.0, y=0.0)

Tworzymy konkretny egzemplarz klasy Object z pozycją (0, 0). Od tej chwili obj to nasz obiekt — ma własne obj.x i obj.y.

print(obj.x, obj.y)

Odczytujemy stan obiektu. obj.x to pozioma pozycja, obj.y to pionowa.

🎉 Gratulacje — obiekt istnieje!

🧱 Pojęcie nr 3 — zmiana stanu

Obiekt sam z siebie się nie porusza.

Żeby go ruszyć, musimy zmienić jego stan — ręcznie, jawnie, bez fizyki.

💡 Dla nowicjusza

Wyobraź sobie szachownicę. Pionek nie rusza się sam. Ktoś (gracz, reguły gry, AI) decyduje o ruchu i zmienia pozycję.

W naszej symulacji tym „kimś" na razie jest funkcja:

def move_right(obj, step):
    obj.x += step

▶️ Oczekiwany wynik po move_right(obj, 1.0)

🔍 Jak działa ten kod — linia po linii

def move_right(obj, step):
    obj.x += step

Funkcja przyjmuje obiekt i krok ruchu. obj.x += step to skrót od obj.x = obj.x + step. Zmienia stan obiektu — x rośnie o step.

🧠 Ważne: Ruch = zmiana stanu w czasie.
Nie: animacja, grafika, fizyka.
Tylko: liczba x się zmieniła.

move_right(obj, 1.0)

Wywołujemy funkcję — obiekt przesuwa się o 1.0 w prawo. obj.x było 0.0, teraz jest 1.0.

❓ Częste błędy

📊 Wizualizacja — punkt w 2D

Teraz musimy to zobaczyć.

💡 Dla nowicjusza — plt.scatter() vs plt.plot()

W L00 używaliśmy plt.plot() — rysuje linię łączącą punkty.
Tu używamy plt.scatter() — rysuje niezależne punkty, bez łączenia.

Dlaczego? Bo w tej lekcji obiekt jest w jednym miejscu — nie ma jeszcze trajektorii ani ruchu jako procesu. scatter mówi: „to jest obserwacja stanu", nie „to jest przebieg w czasie".

plt.scatter(x, y, s=100)  # s = rozmiar punktu w pikselach²
plt.xlim(-5, 5)         # zakres osi X
plt.ylim(-5, 5)         # zakres osi Y
plt.grid()               # siatka pomocnicza

▶️ Oczekiwany wynik

Wykres z jednym czerwonym punktem. Oś X od -5 do 5, oś Y od -5 do 5. Po move_right(obj, 2) punkt przesunie się w prawo.

🔍 Jak działa ten kod — linia po linii

self.history = [(x, y)]

Lista krotek — każda krotka to (x, y) w danym kroku. Zaczyna od pozycji startowej. (0.0, 0.0) jeśli obiekt zaczyna w środku.

def save(self):
    self.history.append((self.x, self.y))

Po każdym ruchu wywołujemy save() — dodajemy aktualną pozycję do historii. Dzięki temu obiekt pamięta skąd przyszedł.

xs = [p[0] for p in obj.history]
ys = [p[1] for p in obj.history]

List comprehension — wyciągamy wszystkie współrzędne X i Y z historii. p[0] = pierwsza wartość krotki = X, p[1] = druga = Y.

plt.scatter(xs[0], ys[0], color='green', label='start')
plt.scatter(xs[-1], ys[-1], color='blue', label='koniec')

xs[0] = pierwszy element = punkt startowy (zielony).
xs[-1] = ostatni element = punkt końcowy (niebieski).
-1 to indeks ostatniego elementu listy w Pythonie.

for i, (x, y) in enumerate(obj.history):
    writer.writerow([i, round(x, 6), round(y, 6)])

enumerate daje pary (numer, wartość). (x, y) to unpacking krotki — rozpakowujemy (1.0, 0.5) na x=1.0 i y=0.5.

🧪 Eksperymenty

obj2 = Object(x=0.0, y=0.0)
move_up(obj2, 1.0)
move_up(obj2, 1.0)
move_up(obj2, 1.0)
draw_trajectory(obj2, title="Ruch w górę")

obj3 = Object(x=0.0, y=0.0)
for _ in range(5):
    move_right(obj3, 0.8)
    move_up(obj3, 0.6)
draw_trajectory(obj3, title="Ruch po skosie")
print("Pozycja końcowa:", obj3.x, obj3.y)

a = Object(x=-2.0, y=0.0)
b = Object(x=2.0, y=0.0)

for _ in range(3):
    move_right(a, 0.5)
    move_up(b, 0.8)

# Narysuj oba na jednym wykresie
plt.figure(figsize=(7, 7))
for obj_plot, color, label in [(a, 'red', 'Obiekt A'), (b, 'blue', 'Obiekt B')]:
    xs = [p[0] for p in obj_plot.history]
    ys = [p[1] for p in obj_plot.history]
    plt.scatter(xs, ys, color=color, s=100, label=label)
    plt.plot(xs, ys, color=color, alpha=0.4)
plt.xlim(-5, 5); plt.ylim(-5, 5)
plt.grid(True, alpha=0.3); plt.legend(); plt.title("Dwa obiekty")
plt.show()

# Czy obiekt "pamięta" że istnieje bez ruchu?
stojak = Object(x=3.0, y=-1.5)
print("Pozycja:", stojak.x, stojak.y)
print("Historia:", stojak.history)
print("Liczba kroków:", len(stojak.history))

# Spróbuj odczytać pozycję 10 razy bez żadnego ruchu
for i in range(10):
    print(f"Odczyt {i}: x={stojak.x}, y={stojak.y}")

🧱 Architektura po Lekcji 01

Jeszcze nie mamy:

🔗 Jak to łączy się z następną lekcją?

Object ma pozycję ale nie ma prędkości. W L02 dodamy vx, vy — prędkość. Ruch przestanie być ręczny (move_right), a stanie się automatyczny: każdy krok czasu (step()) zmienia pozycję o prędkość. To jest przejście od kinematyki do dynamiki.

🧠 Podsumowanie Lekcji 01

Po tej lekcji mamy:

• ✅ Object — punkt w przestrzeni 2D
• ✅ x, y — stan pozycji
• ✅ history — pamięć pozycji
• ✅ move_right(), move_up() — zmiana stanu
• ✅ draw_object(), draw_trajectory() — wizualizacja
• ✅ CSV z historią pozycji

🔜 Co w Lekcji 02?

👉 Lekcja 02 — Ruch w czasie

Dodamy:

• prędkość vx, vy w Object
• funkcję update(obj, world) — jeden krok fizyki
• ruch jako automatyczny proces (nie ręczny)
• trajektorię w czasie

🧠 Złota myśl:

Ruch to zmiana stanu.
Ale najpierw musi istnieć coś, co można zmienić.

🐍 Nowe rozkazy Pythona w tej lekcji

💡 Krotka vs lista

lista = [1, 2, 3]  # można zmieniać: lista[0] = 99
krotka = (1, 2, 3)  # niemutowalna: nie można zmienić elementu

pozycja = (3.0, -1.5)  # krotka — dobra do przechowywania pary (x, y)
x = pozycja[0]  # → 3.0
y = pozycja[1]  # → -1.5

# Unpacking — wygodny skrót:
x, y = pozycja  # x=3.0, y=-1.5

💡 List comprehension

historia = [(0,0), (1,0), (2,0), (3,0)]

# Bez list comprehension:
xs = []
for p in historia:
    xs.append(p[0])

# Z list comprehension (krócej):
xs = [p[0] for p in historia  # → [0, 1, 2, 3]

📋 Ściągawka — Lekcja 01

✅ Checklista — Obiekt i stan

Sprawdź, czy naprawdę rozumiesz:

• Czy wiesz, że Object posiada atrybuty x i y?
• Czy rozumiesz, że x i y opisują aktualną pozycję obiektu?
• Czy wiesz, że history to lista krotek (x, y) — jedna na każdy krok?
• Czy wiesz, że save() dodaje aktualną pozycję do history?
• Czy rozumiesz, że move_right() zmienia x, a nie tworzy nowego obiektu?
• Czy wiesz, że obiekt nie ma prędkości w tej lekcji?
• Czy wiesz, że obiekt nie wie że istnieje World?
• Czy rozumiesz czym różni się plt.scatter() od plt.plot()?
• Czy potrafisz napisać funkcję move_left(obj, step)?
• Czy rozumiesz, że xs[-1] zwraca ostatni element listy?
• Czy potrafisz wyciągnąć wszystkie X z historii jedną linią kodu?
• Czy rozumiesz, że dwa obiekty a i b mają niezależne stany?

🎯 Zadania z charakterem

🟢 Zadanie 1 — Co naprawdę jest stanem?

Masz klasę Object z atrybutami x i y.

Zrób to w Jupyter:

obj_a = Object(x=1.0, y=2.0)
obj_b = Object(x=1.0, y=2.0)

print("Czy mają ten sam stan?", obj_a.x == obj_b.x and obj_a.y == obj_b.y)
print("Czy to ten sam obiekt?", obj_a is obj_b)

• Czy dwa obiekty z tą samą pozycją to ten sam obiekt?
• Czy x i y należą do obiektu czy do świata?
• Czy metoda move_right() jest częścią stanu?

🟢 Zadanie 2 — Ruch bez prędkości

Zrób to w Jupyter:

obj = Object(x=0.0, y=0.0)

# Wywołaj move_right 5 razy
for i in range(5):
    move_right(obj, 0.5)
    print(f"Krok {i+1}: x={obj.x}")

print("Historia:", obj.history)

• Ile elementów ma historia po 5 ruchach?
• Czy do zmiany pozycji potrzebna jest prędkość?
• Jak różni się ten ruch od tego co będzie w L02?

🟡 Zadanie 3 — Dane vs operacje

Masz:

• atrybuty x, y — dane
• funkcje move_right(), move_up() — operacje

Zrób to w Jupyter:

obj = Object(x=0.0, y=0.0)

# Czy dane zmienią się bez wywołania operacji?
print("Przed:", obj.x)
# (Nie rób nic)
print("Po:", obj.x)

# A teraz z operacją:
move_right(obj, 3.0)
print("Po move_right:", obj.x)

• Czy operacja może istnieć bez danych?
• Czy dane zmienią się same bez wywołania funkcji?

🟡 Zadanie 4 — Napisz własne funkcje ruchu

Napisz i przetestuj:

def move_left(obj, step):
    # uzupełnij

def move_down(obj, step):
    # uzupełnij

def move_diagonal(obj, step_x, step_y):
    # uzupełnij — ruch po skosie

Narysuj kwadrat: prawo → góra → lewo → dół → punkt startowy.

🔴 Zadanie 5 — Tożsamość obiektu

obj = Object(x=0.0, y=0.0)
original_id = id(obj)

for _ in range(10):
    move_right(obj, 1.0)

print("Ten sam obiekt?", id(obj) == original_id)
print("Pozycja końcowa:", obj.x)

• Czy po 10 ruchach to nadal ten sam obiekt w pamięci?
• Co się zmienia, a co pozostaje takie samo?
• Co id() mówi o tożsamości obiektu w Pythonie?

🏆 Zadanie mistrzowskie — Object bez atrybutów

Wyobraź sobie klasę Object bez x i y:

class ObjectBezStanu:
    def move_right(self, step):
        pass  # co tu miałoby się zmienić?

• Czy można mówić o położeniu takiego obiektu?
• Czy move_right() mogłoby cokolwiek zmienić?
• Czy można sprawdzić gdzie jest?
• Co jest absolutnym minimum żeby obiekt miał stan?

Następnie udowodnij swoją odpowiedź kodem.

✅ Odpowiedzi — Checklista

1. Tak — Object ma x i y, tworzone w __init__ jako self.x = x, self.y = y.
2. Tak — x i y to aktualny stan — gdzie obiekt jest teraz. Nie historia, nie przyszłość.
3. Tak — history to lista krotek [(x, y), ...]. Zaczyna od [(x_start, y_start)], rośnie po każdym save().
4. Tak — save() wykonuje self.history.append((self.x, self.y)) — dokłada aktualną pozycję na koniec listy.
5. Tak — move_right() modyfikuje self.x istniejącego obiektu. obj = Object(...) tworzy raz, potem tylko modyfikujemy.
6. Tak — brak vx, vy. Prędkość pojawi się w L02.
7. Tak — Object nie zna World. Nie ma atrybutu world ani time. To celowe — separacja odpowiedzialności.
8. scatter rysuje niezależne punkty (obserwacje stanu). plot łączy punkty linią (przebieg w czasie). W L01 nie mamy jeszcze procesu w czasie — tylko punkty.
9. def move_left(obj, step): obj.x -= step; obj.save() — minus zamiast plus.
10. Tak — lista[-1] w Pythonie to ostatni element. lista[-2] to przedostatni. Działa dla każdej listy.
11. xs = [p[0] for p in obj.history] — list comprehension wyciąga pierwszą wartość każdej krotki.
12. Tak — każda instancja Object ma własne x, y, history. a.x = 5 nie zmienia b.x.

🎯 Odpowiedzi — Zadania z charakterem

🟢 Zadanie 1 — Co naprawdę jest stanem?

obj_a i obj_b mają ten sam stan (x=1.0, y=2.0) ale to różne obiekty w pamięci (obj_a is obj_b → False).

x i y należą do obiektu — są jego atrybutami, nie globalnymi zmiennymi.

move_right() to operacja, nie stan — stan to tylko dane (x, y).

🟢 Zadanie 2 — Ruch bez prędkości

Po 5 ruchach historia ma 6 elementów: [(0,0), (0.5,0), (1.0,0), ..., (2.5,0)] — punkt startowy + 5 kroków.

Prędkość nie jest potrzebna — pozycja zmienia się bezpośrednio przez x += step.

W L02 prędkość będzie automatycznie zmieniać pozycję w każdym step() świata.

🟡 Zadanie 3 — Dane vs operacje

Dane nie zmienią się bez wywołania funkcji — obj.x pozostaje 0.0 dopóki nic nie wywoła move_right().

Operacja bez danych nie ma sensu — move_right() musi mieć coś do zmiany (obj.x).

🟡 Zadanie 4 — Napisz własne funkcje ruchu

def move_left(obj, step):
    obj.x -= step
    obj.save()

def move_down(obj, step):
    obj.y -= step
    obj.save()

def move_diagonal(obj, step_x, step_y):
    obj.x += step_x
    obj.y += step_y
    obj.save()

# Kwadrat:
obj = Object(x=0.0, y=0.0)
move_right(obj, 2.0)
move_up(obj, 2.0)
move_left(obj, 2.0)
move_down(obj, 2.0)
draw_trajectory(obj, title="Kwadrat")

🔴 Zadanie 5 — Tożsamość obiektu

Po 10 ruchach id(obj) == original_id → True — to ten sam obiekt w pamięci.

Zmienia się x (i history) — pozostaje tożsamość obiektu (adres w pamięci).

id() zwraca unikalny identyfikator obiektu. Modyfikacja atrybutów nie tworzy nowego obiektu.

🏆 Zadanie mistrzowskie — Object bez atrybutów

Bez x i y nie można opisać położenia — nie ma żadnej wartości która by je reprezentowała.

move_right() nie miałoby co zmieniać — brak danych = brak stanu.

Absolutne minimum: przynajmniej jeden atrybut przechowujący dane.

class ObjectBezStanu:
    def move_right(self, step):
        pass  # nie ma self.x — nic się nie zmienia

obj = ObjectBezStanu()
obj.move_right(5.0)
print(obj.x)  # → AttributeError: 'ObjectBezStanu' has no attribute 'x'

Obiekt istnieje przez stan, nie przez ruch.
Ruch bez stanu to funkcja bez danych — pusty gest.

🧠 Zasada Profesora

Obiekt istnieje przez stan, nie przez ruch.

Możesz mieć obiekt który nigdy się nie poruszy — i to jest poprawny obiekt.
Nie możesz mieć ruchu bez obiektu który ma stan.

Najpierw co istnieje, potem jak się zmienia.

🔥 Złota Myśl

Ruch to zmiana stanu.
Ale najpierw musi istnieć coś, co można zmienić.