📓 Lekcja 02 — Ruch w czasie

📍 Gdzie jesteśmy?

Mamy obiekt z pozycją. Czas dodać prędkość i sprawić żeby się naprawdę poruszał.

🔄 Co nowego w tej lekcji

Jedna kluczowa nowość: update(obj, dt) — ruch jako zmiana stanu w czasie.

Co się zmienia względem L01:

⚠️ Zanim zaczniesz

Potrzebujesz z L00 i L01:

• Wiesz czym jest dt — krok czasu symulacji
• Wiesz czym jest class Object z atrybutami x, y
• Rozumiesz self.history jako listę zapisanych stanów
• Masz zainstalowane matplotlib, jupyter, numpy

🎯 Cel lekcji

Po tej lekcji:

• ✅ obiekt porusza się w czasie — nie skacze, ale płynie
• ✅ rozumiesz prędkość jako atrybut stanu
• ✅ wiesz po co jest dt w równaniu x += vx * dt
• ✅ widzisz trajektorię — historię ruchu w czasie
• ✅ rozumiesz czym różni się update() od move_right()

Nadal nie mamy:

• ❌ ruchu w osi Y (to L03)
• ❌ grawitacji ani żadnych sił (to L05+)
• ❌ kolizji

🏛️ Anegdota historyczna

Galileusz i równomierne przyspieszenie — 1604

Zanim Newton sformułował prawa ruchu, Galileusz Galilei prowadził eksperymenty z kulkami toczącymi się po pochylniach. Odkrył coś zaskakującego: droga jest proporcjonalna do kwadratu czasu, nie do czasu.

Ale żeby to odkryć, musiał najpierw rozwiązać prostszy problem: jak mierzyć czas wystarczająco dokładnie? Zegary były wtedy za wolne. Galileusz używał własnego pulsu, a później wynalazł metodę ważenia wody wypływającej z naczynia jako miary czasu.

Kluczowe odkrycie: prędkość i czas to dwie osobne rzeczy. Obiekt może mieć prędkość ale stać w miejscu (w sensie: dt = 0). Obiekt może być w miejscu i mieć czas — ale bez prędkości nie ruszy.

Brzmi znajomo?

obj.x += obj.vx * dt  # Galileusz by to rozpoznał

🧠 Galileusz mierzył ruch kulkami i wodą.
My mierzymy go pikselami i dt.
Równanie to samo.

🧠 Problem, który rozwiązujemy

W L01 robiliśmy tak:

move_right(obj, 1.0)  # skok o 1.0

To NIE jest ruch. To teleport. Brakuje pytania: „ile czasu to zajęło?"

💡 Dla nowicjusza

Wyobraź sobie że chcesz opisać auto jadące 100 km/h.

• Wersja L01: auto.x += 100 — teleport na 100 km
• Wersja L02: auto.x += 100 * 0.001 — przejechało 0.1 km w ciągu 0.001 godziny

Ruch = prędkość × czas.
Bez czasu mamy tylko teleporty.

🧱 Pojęcie nr 1 — prędkość (vx)

💡 Dla nowicjusza

Prędkość to: jak szybko zmienia się pozycja.

Na razie tylko w osi X — jedna liczba:

• vx = 1.0 — porusza się w prawo, 1 jednostka na sekundę symulacji
• vx = -1.0 — porusza się w lewo
• vx = 0.0 — stoi w miejscu

Prędkość to część stanu obiektu — obiekt ją niesie, świat jej nie zmienia (jeszcze).

class Object:
    def __init__(self, x, y, vx):
        self.x = x
        self.y = y
        self.vx = vx  # ← NOWOŚĆ — prędkość pozioma

🧱 Pojęcie nr 2 — update(obj, dt)

To jest najważniejsza funkcja kursu. Przez kolejne 20 lekcji będzie rosnąć, ale nigdy nie zniknie.

def update(obj, dt):
    obj.x += obj.vx * dt

Czytaj na głos: „pozycja x zwiększa się o prędkość razy czas"

💡 Dla nowicjusza

Jeśli auto jedzie 100 km/h i mija 0.5 godziny:

W symulacji:

obj.x += obj.vx * dt  # np. 1.0 * 0.1 = 0.1 jednostki na krok

Czym różni się od move_right()?

🧪 Symulacja ruchu

▶️ Oczekiwany wynik

Linia prosta na wykresie — stała prędkość, brak zakrętów.

🔍 Jak działa ten kod — linia po linii

self.vx = vx

Nowy atrybut — prędkość pozioma. Obiekt ją niesie jak własną cechę. Nie zmienia jej sam — zmieni ją dopiero update() albo wpływy w L05+.

self.save()  # w __init__

Wywołujemy save() już w konstruktorze — zapisujemy pozycję startową. Dzięki temu history[0] zawsze jest punkt startowy, nie pierwszy krok.

def update(obj, dt):
    obj.x += obj.vx * dt
    obj.save()

Dwie linijki — cała fizyka tej lekcji. Najpierw przesuwamy (x += vx * dt), potem zapisujemy nową pozycję. Kolejność ma znaczenie — save() po update, nie przed.

DT = 0.1  # ⚙️ PARAMETRY EKSPERYMENTU

Stała na górze kodu — łatwo zmienić, łatwo zobaczyć. Konwencja: parametry eksperymentu = wielkie litery.

for step in range(STEPS):
    update(obj, DT)

Pętla symulacji. Każde wywołanie update() = jeden krok czasu. obj zmienia się w miejscu — nie tworzymy nowego obiektu.

❓ Częste błędy

🧪 Eksperymenty

DT = 0.5   # duży krok
DT = 0.01  # mały krok

VX = -1.0  # prędkość w lewo

obj_a = Object(x=0.0, y=1.0, vx=1.0)
obj_b = Object(x=0.0, y=3.0, vx=2.5)

for _ in range(20):
    update(obj_a, DT)
    update(obj_b, DT)

plt.figure(figsize=(10, 5))
for obj_plot, color, label in [(obj_a,'red','vx=1.0'), (obj_b,'blue','vx=2.5')]:
    xs = [p[0] for p in obj_plot.history]
    ys = [p[1] for p in obj_plot.history]
    plt.plot(xs, ys, color=color, label=label)
    plt.scatter(xs, ys, color=color, s=20)
plt.legend(); plt.grid(True, alpha=0.3); plt.show()

# Zapisuj tylko co 5. krok
obj2 = Object(x=0.0, y=0.0, vx=1.0)
obj2.history = []  # wyczyść historię startową

for step in range(50):
    update(obj2, DT)
    if step % 5 == 0:
        obj2.save()  # nadpisz save() w pętli

print(f"Kroków: 50 | Punktów w historii: {len(obj2.history)}")

🧱 Architektura po Lekcji 02

Jeszcze nie mamy:

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

Object ma teraz vx ale brak vy — porusza się tylko poziomo. W L03 dodamy vy i ruch stanie się dwuwymiarowy: obiekt będzie poruszać się po płaszczyźnie XY. update() rozszerzy się o y += vy * dt.

🧠 Podsumowanie Lekcji 02

Po tej lekcji mamy:

• ✅ vx — prędkość jako część stanu obiektu
• ✅ update(obj, dt) — jeden krok fizyki: x += vx * dt
• ✅ save() — świadome zapisywanie historii
• ✅ trajektoria jako historia pozycji w czasie
• ✅ CSV z historią kroków

🔜 Co w Lekcji 03?

👉 Lekcja 03 — Ruch w 2D

Dodamy:

• vy — prędkość pionowa
• update() rozszerzony o y += vy * dt
• ruch po płaszczyźnie XY
• wizualizację wektorów prędkości

🧠 Złota myśl:

Ruch bez czasu to teleport.
Czas bez ruchu to cisza.
x += vx * dt — właśnie sprawiliśmy że świat zaczął płynąć.

🐍 Nowe rozkazy Pythona w tej lekcji

💡 += — skrót od dodania i przypisania

obj.x += obj.vx * dt
# to samo co:
obj.x = obj.x + obj.vx * dt

+= jest krótsze i działa w miejscu — modyfikuje istniejącą zmienną.

💡 Dlaczego save() jest osobną metodą?

# ZŁY POMYSŁ — save() automatycznie w update():
def update(obj, dt):
    obj.x += obj.vx * dt
    obj.history.append((obj.x, obj.y))  # zawsze zapisuje

# DOBRY POMYSŁ — save() to decyzja:
def update(obj, dt):
    obj.x += obj.vx * dt
    obj.save()  # wywołaj kiedy chcesz

Oddzielenie fizyki (update) od obserwacji (save) to zasada przez cały kurs. save() to kamera — kamera nie zmienia fizyki.

💡 history[0] vs history[-1]

obj.history[0]    # pierwsza pozycja — startowa
obj.history[-1]   # ostatnia pozycja — aktualna
obj.history[5]    # szósta pozycja (indeksy od 0)

📋 Ściągawka — Lekcja 02

✅ Checklista — Ruch w czasie

Sprawdź, czy naprawdę rozumiesz:

• Czy wiesz, że Object ma teraz atrybut vx — prędkość w osi x?
• Czy rozumiesz, że update(obj, dt) wykonuje obj.x += obj.vx * dt?
• Czy wiesz, że bez dt > 0 obiekt się nie porusza?
• Czy rozumiesz czym różni się update() od move_right() z L01?
• Czy wiesz, że save() to narzędzie obserwacji — nie fizyka?
• Czy rozumiesz, że history[0] to pozycja startowa?
• Czy wiesz, że ujemne vx oznacza ruch w lewo?
• Czy potrafisz obliczyć pozycję końcową bez uruchamiania kodu: x = x0 + vx × dt × steps?
• Czy rozumiesz, że mniejsze dt = wolniejszy ruch w tej samej liczbie kroków?
• Czy wiesz, że obj.vx pozostaje stałe przez całą symulację (w tej lekcji)?

🎯 Zadania z charakterem

🟢 Zadanie 1 — Bez czasu

Wyobraź sobie symulację z dt = 0.

Zrób to w Jupyter:

obj = Object(x=0.0, y=0.0, vx=5.0)
for _ in range(100):
    update(obj, 0)  # dt = 0
print(f"Pozycja po 100 krokach: x={obj.x}")

• Czy pozycja się zmienia?
• Czy prędkość vx = 5.0 cokolwiek znaczy bez czasu?
• Co to mówi o roli dt w symulacji?

🟢 Zadanie 2 — Zmiana kroku czasu

Zrób to w Jupyter:

for dt_test in [0.01, 0.1, 0.5, 1.0]:
    obj = Object(x=0.0, y=0.0, vx=1.0)
    for _ in range(30):
        update(obj, dt_test)
    print(f"dt={dt_test}: x końcowe = {obj.x:.2f}")

• Czy wzór update() się zmienia?
• Dlaczego x końcowe jest różne?
• Które dt daje gładszą trajektorię?

🟡 Zadanie 3 — Stała prędkość

Prędkość vx jest stała przez całą symulację.

• Jak wygląda wykres x(krok)? Prosta czy krzywa?
• Co musiałoby się zmienić żeby pojawił się zakręt?
• Oblicz ręcznie: przy vx=2.0, dt=0.1, 50 krokach — jaka będzie x końcowa?

🟡 Zadanie 4 — save() jako decyzja

Napisz symulację gdzie zapisujesz tylko co 10. krok:

obj = Object(x=0.0, y=0.0, vx=1.0)
obj.history = []  # wyczyść historię startową

for step in range(100):
    update(obj, 0.1)
    if step % 10 == 0:
        obj.save()

print(f"Kroków: 100, punktów w historii: {len(obj.history)}")
draw_update(obj, title="Co 10. krok")

• Ile punktów jest w historii?
• Czy ruch się odbył mimo że mało zapisaliśmy?
• Jak wygląda wykres w porównaniu do pełnego zapisu?

🔴 Zadanie 5 — Ujemny krok czasu

Zrób to w Jupyter:

obj = Object(x=5.0, y=0.0, vx=1.0)
for _ in range(50):
    update(obj, -0.1)  # ujemny dt!
print(f"Pozycja końcowa: x={obj.x:.2f}")

• Co się dzieje z x?
• Czy ruch w „cofniętym czasie" jest symetryczny?
• Czy to ma sens fizyczny?

🏆 Zadanie mistrzowskie — Dwa światy

# Świat A: mały dt, dużo kroków
obj_a = Object(x=0.0, y=1.0, vx=1.0)
for _ in range(1000):
    update(obj_a, 0.01)

# Świat B: duży dt, mało kroków
obj_b = Object(x=0.0, y=3.0, vx=1.0)
for _ in range(10):
    update(obj_b, 1.0)

print(f"Świat A: {1000} kroków × dt=0.01 → x={obj_a.x:.2f}, czas={1000*0.01:.1f}s")
print(f"Świat B: {10} kroków × dt=1.0 → x={obj_b.x:.2f}, czas={10*1.0:.1f}s")

• Który świat osiągnął dalej?
• Który ma więcej obliczeń?
• Co się dzieje z dokładnością przy dużym dt gdy pojawi się grawitacja (L05)?
• Czy istnieje idealny dt?

✅ Odpowiedzi — Checklista

1. Tak — Object w L02 ma self.vx = vx w konstruktorze — prędkość pozioma jako część stanu.
2. Tak — update(obj, dt) wykonuje obj.x += obj.vx * dt, potem obj.save().
3. Tak — x += vx * 0 = 0 — pozycja się nie zmienia. dt = 0 zatrzymuje czas.
4. move_right(obj, step) zmienia pozycję o stały skok bez pojęcia czasu. update(obj, dt) łączy prędkość z czasem — ruch jest proporcjonalny do dt.
5. Tak — save() to narzędzie obserwacji: nie wywołaj jej → ruch się odbywa, historia zostaje pusta.
6. Tak — save() wywołana w __init__ → history[0] = (x_start, y_start).
7. Tak — x += vx * dt = x + (-1.0) * 0.1 = x - 0.1 — x maleje z każdym krokiem.
8. Tak — x_końcowe = x_0 + vx × dt × steps. Np. 0 + 2.0 × 0.1 × 30 = 6.0.
9. Tak — x += vx × dt. Mniejsze dt → mniejszy przyrost na krok → wolniejszy ruch w tej samej liczbie kroków.
10. Tak — vx jest atrybutem obiektu i nie jest modyfikowane przez update(). Zmienia się dopiero gdy w L05+ dodamy przyspieszenie.

🎯 Odpowiedzi — Zadania z charakterem

🟢 Zadanie 1 — Bez czasu

x += 5.0 × 0 = 0 — pozycja się nie zmienia mimo 100 kroków i vx = 5.0. dt = 0 eliminuje powiązanie prędkości z przestrzenią. Prędkość istnieje, ale nie ma czasu w którym mogłaby działać. To potwierdza: ruch = prędkość × czas. Bez czasu są tylko teleporty.

🟢 Zadanie 2 — Zmiana kroku czasu

Wzór update() się nie zmienia — zawsze x += vx * dt. x końcowe różne bo: x = vx × dt × 30 = 1.0 × dt × 30.

• dt=0.01 → x = 0.30
• dt=1.0 → x = 30.0

Mniejszy dt = gładszy wykres (więcej punktów na jednostkę czasu).

🟡 Zadanie 3 — Stała prędkość

Wykres x(krok) jest linią prostą — każdy krok dodaje tę samą wartość vx × dt. Żeby pojawił się zakręt: vx musiałoby się zmieniać w czasie (przyspieszenie — L05+). Obliczenie: x = 0 + 2.0 × 0.1 × 50 = 10.0.

🟡 Zadanie 4 — save() jako decyzja

Historia ma 10 punktów (kroki 0, 10, 20, ..., 90). Ruch się odbył — 100 kroków wykonane. Historia jest wybiórcza. Wykres wygląda rzadziej (mniej punktów), ale kształt taki sam — linia prosta.

🔴 Zadanie 5 — Ujemny krok czasu

x += 1.0 × (-0.1) = x - 0.1 — x maleje: 5.0 → 4.9 → 4.8 → ... → 0.0. Ruch jest symetryczny względem znaku dt przy stałym vx. Fizycznie: cofanie czasu. Matematycznie poprawne. W praktyce: rzadko używane.

🏆 Zadanie mistrzowskie — Dwa światy

Oba światy mają ten sam czas symulacji: 1000 × 0.01 = 10s = 10 × 1.0. Oba osiągają x = vx × czas = 1.0 × 10 = 10.0 — taką samą pozycję. Świat A ma 1000 obliczeń, Świat B ma 10 — ale wynik identyczny (przy stałym vx). Gdy pojawi się grawitacja (L05): duże dt da błędy numeryczne — krzywizna trajektorii będzie zdeformowana. Idealny dt nie istnieje — zawsze kompromis między dokładnością a szybkością.

🧠 Zasada Profesora

Ruch to zmiana stanu względem czasu, nie dodatek do obiektu.

update() to nie dekoracja — to fundament całej fizyki symulacji. Przez kolejne 20 lekcji będzie rosnąć, ale ta jedna linijka zawsze zostanie:

obj.x += obj.vx * dt

🔥 Złota Myśl

Ruch bez czasu to teleport.
Czas bez ruchu to cisza.
x += vx * dt — właśnie sprawiliśmy że świat zaczął płynąć.