📓 Lekcja 00 — Świat, który jeszcze nic nie robi

📍 Gdzie jesteśmy?

Jesteś na początku. To lekcja zerowa — fundament pod wszystko co nastąpi.

🔄 Co nowego w tej lekcji

To lekcja zerowa. Jedyna zmiana: świat umie liczyć czas.

⚠️ Zanim zaczniesz

Potrzebujesz tylko:

• Zainstalowanego Pythona (3.8+)
• Zainstalowanego matplotlib (pip install matplotlib)
• Otwartego Jupyter Notebook lub dowolnego edytora Python

Jeśli to Twój pierwszy kontakt z programowaniem — spokojnie. Każda nowa komenda będzie wyjaśniona od podstaw.

🛠️ Instalacja środowiska — krok po kroku

Zrób to raz przed pierwszą lekcją. Potem już tylko otwierasz Jupyter i pracujesz.

💻 Krok 1 — Zainstaluj Pythona

1. Wejdź na python.org/downloads
2. Pobierz najnowszą wersję Python 3.x (np. 3.11 lub 3.12)
3. Uruchom instalator

4. Kliknij „Install Now" i poczekaj

Sprawdź czy działa — otwórz terminal i wpisz:

python --version

Powinieneś zobaczyć: Python 3.x.x

📦 Krok 2 — Zainstaluj biblioteki

Jak otworzyć terminal?

• Windows: Wciśnij Win + R, wpisz cmd, Enter — albo wyszukaj „Wiersz polecenia" w menu Start
• Mac: Command + Spacja, wpisz Terminal, Enter
• Linux: Ctrl + Alt + T

W terminalu wpisz kolejno:

pip install jupyter
pip install jupyterlab
pip install matplotlib
pip install numpy

Albo wszystko naraz:

pip install jupyter jupyterlab matplotlib numpy

Instalacja może potrwać kilka minut. Zobaczysz dużo tekstu — to normalne.

Sprawdź czy działa:

jupyter --version

Powinieneś zobaczyć kilka linii z wersjami.

🚀 Krok 3 — Uruchom Jupyter Lab

1. W terminalu przejdź do folderu gdzie chcesz trzymać pliki kursów:

   cd C:\Users\TwojeImie\Desktop\kurs-ai  # Windows
   cd ~/Desktop/kurs-ai  # Mac / Linux

   Jeśli folder nie istnieje — utwórz go najpierw:

   mkdir kurs-ai
   cd kurs-ai

2. Uruchom Jupyter Lab:

   jupyter lab

3. Automatycznie otworzy się przeglądarka internetowa z interfejsem:

   http://localhost:8888/lab

📂 Krok 4 — Otwórz notebook z kursem

Jeśli pobrałeś plik .ipynb:

• W panelu po lewej stronie Jupyter Lab znajdź plik
• Kliknij dwukrotnie żeby go otworzyć

Jeśli tworzysz nowy:

• File → New → Notebook
• Wybierz kernel: Python 3

▶️ Krok 5 — Uruchamianie komórek

❓ Częste problemy

🎯 Cel lekcji

Po tej lekcji:

• ❌ NIC się nie porusza
• ❌ NIE ma fizyki
• ❌ NIE ma obiektów

ALE:

• ✅ istnieje świat
• ✅ istnieje czas
• ✅ istnieje krok symulacji

I to wystarczy, żeby zacząć prawdziwą symulację.

⚠️ Celowo nudne. Jeśli wydaje Ci się „za proste" — dokładnie o to chodzi 😄

🏛️ Anegdota historyczna

Newton vs Leibniz — co to jest czas?

W XVII wieku Isaac Newton twierdził, że czas płynie absolutnie — jednakowo wszędzie we wszechświecie, niezależnie od obserwatora. Był jak wielka rzeka płynąca sama z siebie.

Gottfried Wilhelm Leibniz się nie zgadzał. Twierdził, że czas to tylko relacja między zdarzeniami — nie istnieje sam w sobie, tylko jako porządek następujących po sobie chwil.

Przez 200 lat wygrywał Newton. Dopiero Einstein w 1905 roku pokazał, że Leibniz miał rację — czas jest względny, zależy od obserwatora i prędkości.

W naszej symulacji czas jest leibnizowski — to po prostu licznik kroków. World nie wie ile „prawdziwego czasu" minęło. Wie tylko że wykonał N kroków. Każde step() to jedno zdarzenie. Czas to relacja między zdarzeniami.

🧠 Paradoks: najprostszy model czasu w kodzie jest bliższy prawdzie niż intuicja Newtona.

🧱 Zasada nr 0 (święta)

Jeśli świat nie zrobi kroku — nic się nie wydarzy.
Nawet najlepsza fizyka.

Na razie świat nie ma przestrzeni, obiektów ani zjawisk. Umie tylko jedno: ⏱️ wiedzieć, która jest chwila symulacji.

🧠 Model myślowy

Wyobraź sobie zegarek ⌚ który:

• nie pokazuje godzin ani minut
• tylko tyka

Każde „tyk" = jeden krok symulacji.

🐍 Nowe rozkazy Pythona w tej lekcji

🧱 Pojęcie nr 1 — class

(czyli: czym jest klasa i po co ona w ogóle istnieje)

💡 Dla nowicjusza

class to przepis na obiekt. Nie sam obiekt — tylko instrukcja jak go stworzyć.

• 👉 forma do ciastek 🍪 — forma ≠ ciastko, ale bez niej nie ma ciastka
• 👉 plan domu 🏠 — plan ≠ dom, ale bez planu nie zbudujesz domu
• 👉 instrukcja LEGO 🧱 — instrukcja ≠ model, ale bez niej chaos

class Samochod:
    ...

auto = Samochod()  # ← dopiero TERAZ powstaje konkretny egzemplarz

Dlaczego używamy class w symulacji?

Bo świat ma stan (wie ile czasu minęło), zachowanie (potrafi wykonać krok) i żyje w czasie (zmienia się krok po kroku). Klasy są idealne do opisywania „czegoś, co istnieje i ma pamięć".

🔍 Jak działa ten kod — linia po linii

class World:

Tworzymy nowy typ danych o nazwie World. Po tej deklaracji Python wie że istnieje coś takiego jak „świat".

def __init__(self, dt):

Konstruktor — specjalna metoda która uruchamia się automatycznie gdy piszesz World(dt=0.1). Słowo self znaczy: „ten konkretny obiekt".

self.time = 0.0  # aktualny czas świata

Każdy świat dostaje swój własny zegar. Zaczynamy od zera. self.time — to atrybut: własna zmienna tego konkretnego obiektu.

self.dt = dt  # krok czasu

dt = delta time = ile czasu mija w jednym kroku. Zapisujemy to w obiekcie żeby pamiętał swoją rozdzielczość.

def step(self):
    self.time += self.dt

Metoda — funkcja należąca do obiektu. step() robi dokładnie jedną rzecz: przesuwa czas o dt.

❓ Częste błędy

🧱 Pojęcie nr 2 — metoda step()

Metoda to funkcja należąca do obiektu — coś co obiekt potrafi zrobić.

def step(self):
    self.time += self.dt  # przesuń czas o jeden krok

Co robi step()? Przesuwa czas o dt. Nic więcej.

Nie porusza, nie liczy, nie symuluje. Po prostu: czas idzie do przodu.

W kolejnych lekcjach step() będzie robić więcej — ale zawsze to właśnie w nim będzie bił puls symulacji. Każde wywołanie step() = jedna tura.

🧪 Uruchamiamy świat

(nic się nie dzieje — i to jest OK)

▶️ Oczekiwany wynik

Czas rośnie o 0.1 po każdym kroku. Świat żyje 🎉
Jeśli nie widzisz tego wyniku — sprawdź czy wywołałeś world.step() w pętli.

🔍 Jak działa ten kod — linia po linii

world = World(dt=0.1)

Tworzymy konkretny świat z krokiem dt=0.1. Od tej chwili world to nasz obiekt — ma swój time, dt i zaraz history.

for i in range(10):

Pętla — wykona się 10 razy. i przyjmuje wartości 0, 1, 2, ..., 9. range(10) generuje liczby od 0 do 9 (nie do 10!).

world.step()

Jeden krok symulacji — czas rośnie o dt. Bez tej linii czas by stał w miejscu.

print(f"Krok {i:02d} | czas świata = {world.time:.2f}")

• f"..." — f-string: wstawiamy zmienne w {}
• {i:02d} — liczba całkowita, minimum 2 cyfry, wypełniona zerami: 00, 01...
• {world.time:.2f} — liczba zmiennoprzecinkowa, 2 miejsca po przecinku

🧠 Ważna obserwacja: Czas w symulacji to umowa, nie prawda absolutna. Świat wie tylko że wykonał N kroków — nie wie czym jest „sekunda".

📊 Pojęcie nr 3 — lista []

(czyli: jak świat pamięta przeszłość)

💡 Dla nowicjusza

Lista to pojemnik na wiele wartości w kolejności.

historia = []          # pusty pojemnik
historia.append(0.0)   # dodajemy → [0.0]
historia.append(0.1)   # dodajemy → [0.0, 0.1]
historia.append(0.2)   # dodajemy → [0.0, 0.1, 0.2]

Analogie:

• 📒 zeszyt — każda linijka to jedna wartość
• 🧾 historia transakcji na koncie — każdy wpis to jeden krok czasu
• 📈 taśma z zapisem temperatury co godzinę

W naszym świecie:

self.history = [0.0]              # zaczynamy z czasem 0.0
self.history.append(self.time)  # po każdym step() → dodajemy aktualny czas

Dzięki temu świat pamięta całą swoją przeszłość — będzie to kluczowe w lekcjach o analizie ruchu.

📊 Wizualizacja czasu

💡 Dla nowicjusza — co to jest matplotlib?

matplotlib to biblioteka do rysowania wykresów w Pythonie. Używają jej naukowcy, inżynierowie i twórcy gier do analizy danych.

import matplotlib.pyplot as plt  # importujemy moduł do rysowania
plt.figure()                      # nowe okno wykresu
plt.plot(x, y, 'o')              # rysuj punkty (marker 'o' = kółko)
plt.xlabel("Krok symulacji")     # opis osi X
plt.ylabel("Czas świata")        # opis osi Y
plt.title("Tytuł wykresu")       # tytuł
plt.grid(True)                    # siatka w tle
plt.show()                        # pokaż wykres

Nie robimy grafiki gry — robimy narzędzie diagnostyczne 🔬

▶️ Oczekiwany wynik

Wykres z 11 punktami (o) ułożonymi wzdłuż linii prostej. Oś X: numery kroków (0–10). Oś Y: czas (0.0–2.5). Punkty rozłożone równomiernie — bo dt jest stałe.

💾 Export do CSV — po co i jak?

Po co w ogóle CSV?

world.history to lista w pamięci Pythona — istnieje tylko dopóki Jupyter jest uruchomiony. Zamkniesz notebook → dane znikają.

CSV (Comma-Separated Values) to plik tekstowy który:

• możesz otworzyć w Excelu i zobaczyć tabelkę
• możesz również obejrzeć w Jupyter lab
• możesz porównać z wynikami z następnych lekcji
• przeżyje zamknięcie Jupytera 😄

Czy world.history i CSV zawierają to samo?

Tak — dokładnie to samo.

🔍 Jak działa ten kod — linia po linii

self.history = [0.0]

Lista startuje z jedną wartością — czasem 0.0 na początku symulacji. [0.0] to skrót od [] + append(0.0).

self.history.append(self.time)

Po każdym step() dokładamy aktualny czas do listy. Lista rośnie z każdym krokiem.

steps = list(range(len(world.history)))

• len(world.history) → liczba elementów w liście (np. 11)
• range(11) → generator liczb 0, 1, 2, ..., 10
• list(...) → zamienia generator na listę [0, 1, 2, ..., 10]

To są numery kroków — oś X wykresu.

plt.plot(steps, world.history, 'o')

Rysuje punkty: X = numer kroku, Y = czas. 'o' = kółka zamiast linii.

🧠 Co pokazuje ten wykres?

• każda kropka = jedno tyknięcie świata
• czas rośnie skokowo, nie płynnie
• odstępy między kropkami = wartość dt

Symulacja nie płynie. Symulacja przeskakuje.
Mniejsze dt → gęstsze kropki → dokładniejsza symulacja.

🧪 Eksperymenty

🟢 Eksperyment 1 — podejrzyj historię

Co robisz: W nowej komórce wpisz i uruchom:

print(world.history)

Co zobaczysz:

Szczegółowe wyjaśnienie: Lista ma 11 elementów: 0.0 na starcie + 10 wartości po każdym step(). Pierwsza wartość 0.0 pochodzi z inicjalizacji self.history = [0.0] w __init__. Ostatnia wartość 2.5 = 10 kroków × dt=0.25. To jest dokładnie to co było rysowane na wykresie — każda kropka = jedna liczba z tej listy.

Dlaczego to ważne: W kolejnych lekcjach history będzie przechowywać pozycje, prędkości, błędy trafienia. Umiejętność podejrzenia historii = umiejętność debugowania symulacji. Pamiętaj: możesz też sprawdzić konkretny element: world.history[0], world.history[-1].

🟢 Eksperyment 2 — kolejność ma znaczenie

Co robisz: Przepisz całą klasę World z zamienioną kolejnością w step(), utwórz nowy świat i sprawdź jego historię:

class WorldV2:
    def __init__(self, dt):
        self.time = 0.0
        self.dt = dt
        self.history = [0.0]

    def step(self):
        self.history.append(self.time)  # ← NAJPIERW zapisz (stara wartość!)
        self.time += self.dt            # ← POTEM zwiększ

world_v2 = WorldV2(dt=0.25)
for _ in range(4):
    world_v2.step()

print("Oryginał:", [0.0, 0.25, 0.5, 0.75, 1.0])  # dla porównania
print("V2: ", world_v2.history)

Co zobaczysz:

Szczegółowe wyjaśnienie:

• Oryginał: najpierw time += dt (czas rośnie do 0.25), potem append(0.25) → lista = [0.0, 0.25, ...]
• V2: najpierw append(0.0) (zapisujemy starą wartość!), potem time += dt → lista = [0.0, 0.0, 0.25, ...]
• Efekt: historia jest spóźniona o jeden krok — każda wartość pojawia się o jeden krok za późno
• Na początku pojawia się duplikat 0.0, 0.0 — bo zapisujemy czas przed jego zwiększeniem
• Na końcu brakuje ostatniej wartości (1.0) — bo po ostatnim append czas dopiero rośnie, ale już nie zapisujemy

Dlaczego to ważne: Kolejność operacji w każdym step() będzie krytyczna w fizyce. W L05+ gdy będziemy liczyć prędkości i pozycje, zła kolejność = błędna trajektoria. To tzw. off-by-one error — jeden z najczęstszych błędów w symulacjach numerycznych.

🟡 Eksperyment 3 — dwie listy jednocześnie

Co robisz: Przepisz klasę World z dodatkową listą kroków:

class WorldV3:
    def __init__(self, dt):
        self.time = 0.0
        self.dt = dt
        self.history = [0.0]
        self.steps = [0]  # ← NOWA lista: numery kroków

    def step(self):
        self.time += self.dt
        self.history.append(self.time)
        self.steps.append(len(self.steps))  # ← numer = długość przed append

world_v3 = WorldV3(dt=0.25)
for _ in range(4):
    world_v3.step()

print("history:", world_v3.history)
print("steps: ", world_v3.steps)
print("Liczba kroków:", world_v3.steps[-1])

Co zobaczysz:

Szczegółowe wyjaśnienie: len(self.steps) przed append zwraca aktualną długość listy — to jednocześnie numer nowego elementu.

• Przed 1. krokiem: len([0]) = 1 → append(1) → [0, 1]
• Przed 2. krokiem: len([0,1]) = 2 → append(2) → [0, 1, 2]

Obie listy rosną synchronicznie — zawsze mają tę samą długość.

Dlaczego to ważne: W L01+ World będzie zarządzać listą obiektów, każdy z własną historią. Wzorzec „wiele list rosnących synchronicznie" pojawi się wielokrotnie.

🔴 Eksperyment 4 — porównanie dt (OBOWIĄZKOWY)

Co robisz: Wklej i uruchom w nowej komórce:

import matplotlib.pyplot as plt

world_a = World(dt=0.05)  # małe kroki — dokładna symulacja
world_b = World(dt=0.50)  # duże kroki — zgrubna symulacja

for _ in range(20):
    world_a.step()
    world_b.step()

steps_a = list(range(len(world_a.history)))
steps_b = list(range(len(world_b.history)))

plt.figure(figsize=(10, 4))
plt.plot(steps_a, world_a.history, 'o-', label=f'dt=0.05 (czas końcowy: {world_a.time:.2f}s)')
plt.plot(steps_b, world_b.history, 's-', label=f'dt=0.50 (czas końcowy: {world_b.time:.2f}s)')
plt.xlabel("Krok symulacji")
plt.ylabel("Czas świata")
plt.title("Wpływ dt na rozdzielczość czasu")
plt.legend()
plt.grid(True)
plt.show()

print(f"Oba wykonały 20 kroków:")
print(f"  dt=0.05 → czas końcowy: {world_a.time:.2f}s (20 × 0.05)")
print(f"  dt=0.50 → czas końcowy: {world_b.time:.2f}s (20 × 0.50)")

Co zobaczysz:

Wykres: linia niebieska gęsta (21 punktów blisko siebie), linia pomarańczowa rzadka (21 punktów daleko od siebie).

Szczegółowe wyjaśnienie:

• Oba światy wykonały dokładnie 20 kroków — ale żyją w różnym tempie
• world_a: krok = 0.05s → po 20 krokach = 1 sekunda symulacji
• world_b: krok = 0.50s → po 20 krokach = 10 sekund symulacji
• Na wykresie oś X (kroki) jest identyczna — oś Y (czas) różna
• Mniejsze dt → gęstsze próbkowanie → dokładniejsza trajektoria w przyszłości
• Większe dt → rzadsze próbkowanie → szybsze obliczenia, ale więcej błędów

Dlaczego to ważne: Wybór dt to jeden z kluczowych parametrów każdej symulacji fizycznej. Zbyt duże dt = symulacja „eksploduje" (błędy numeryczne narastają). Zbyt małe dt = symulacja trwa wieki. W naszej serii używamy dt=0.05 jako kompromis — dobre wyniki, rozsądna szybkość.

🧱 Architektura po Lekcji 00

Jeszcze nie mamy — pojawi się stopniowo:

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

World zarządza czasem. W L01 dodamy Object który zarządza stanem (pozycja x, y, prędkość vx, vy). Oba będą działać razem: świat wyznacza rytm, obiekt zmienia stan w każdym kroku.

🧠 Podsumowanie Lekcji 00

Po tej lekcji mamy:

• ✅ World — pierwszy byt w symulacji
• ✅ time — zegar świata
• ✅ dt — krok czasu (rozdzielczość)
• ✅ history — pamięć przeszłości
• ✅ step() — jedna tura symulacji
• ✅ Wizualizacja czasu (matplotlib)
• ✅ Export do CSV

🔜 Co w Lekcji 01?

👉 Lekcja 01 — Object i stan

Dodamy:

• class Object z pozycją x, y
• prędkość vx, vy
• pierwszy ruch (bez fizyki!)
• wizualizację trajektorii

🧠 Złota myśl:

Ruch bez struktury to chaos.
Struktura bez ruchu to potencjał.

Lekcja 00 to moment, w którym budujesz miejsce, w którym coś będzie mogło się dziać. 🚀

📝 Dodatek — for, print i f-stringi

🔁 Pętla for

💡 Dla nowicjusza

Pętla for powtarza blok kodu określoną liczbę razy.

for i in range(5):
    print(i)
# Wypisze: 0 1 2 3 4

range(5) — generuje liczby od 0 do 4 (nie do 5!).
range(1, 6) — generuje liczby od 1 do 5.
range(0, 10, 2) — co drugi: 0, 2, 4, 6, 8.

Zastosowanie w symulacji:

for krok in range(100):
    world.step()  # wykonaj 100 kroków świata

🧵 F-string — formatowanie tekstu

Przed cudzysłowem stawiasz f, zmienne wstawiasz w {}:

imie = "Symulacja"
krok = 5
czas = 0.123456
print(f"To jest {imie}, krok nr {krok}, czas = {czas:.3f}.")
# → To jest Symulacja, krok nr 5, czas = 0.123.

Formatowanie liczb:

▶️ Oczekiwany wynik poniższego kodu

📋 Ściągawka — Lekcja 00

✅ Checklista — Świat, który jeszcze nic nie robi

Sprawdź, czy naprawdę rozumiesz:

• Czy wiesz, że World posiada atrybut time?
• Czy wiesz, że time jest inicjalizowane wartością 0.0?
• Czy wiesz, że dt jest przekazywane w konstruktorze i zapisywane w obiekcie?
• Czy rozumiesz, że step() wykonuje self.time += self.dt?
• Czy wiesz, że time zmienia się wyłącznie w step()?
• Czy wiesz, że history to lista kolejnych wartości time?
• Czy wiesz, że World nie ma żadnych atrybutów ruchu (pozycja, prędkość)?
• Czy wiesz, że World nie ma listy obiektów?
• Czy rozumiesz, że jedyna zmiana stanu to time += dt?
• Czy rozumiesz że World to zegar — nie silnik fizyczny?
• Czy potrafisz wytłumaczyć różnicę między dt a time własnymi słowami?
• Czy wiesz czym różni się dt=0.05 od dt=1.0 w praktyce?
• Czy potrafisz uruchomić world.step() 100 razy używając pętli for?

🎯 Zadania z charakterem

🟢 Zadanie 1 — Fundament czasu

Pytania do przemyślenia:

• Czy świat może istnieć bez ruchu?
• Czy sam mechanizm upływu czasu jest już systemem?
• Dlaczego zaczynamy budowę symulacji od czasu, a nie od obiektu?

Zrób to w Jupyter: Uruchom poniższy kod i odpowiedz — czy dwa światy są identyczne?

world_x = World(dt=0.1)
world_y = World(dt=0.1)

for _ in range(5):
    world_x.step()
    world_y.step()

print("world_x.time:", world_x.time)
print("world_y.time:", world_y.time)
print("Czy identyczne?", world_x.time == world_y.time)

Co to mówi o naturze tego „świata"?

🟢 Zadanie 2 — Rola dt

Pytania:

• Czym różni się dt od time? Podaj analogię z życia codziennego.
• Dlaczego dt należy do świata, a nie do przyszłego obiektu?

Zrób to w Jupyter: Uzupełnij i uruchom:

# Utwórz świat z dt=0, wykonaj krok i sprawdź czas
world_zero = World(dt=0)
world_zero.step()
print("czas po kroku z dt=0:", world_zero.time)
# Co widzisz? Dlaczego?

🟡 Zadanie 3 — Metoda step()

• Czy step() zmienia coś poza time?
• Co by się stało gdybyś wywołał step() dwa razy w jednej turze zamiast raz?

Zrób to w Jupyter: Dodaj licznik wywołań do World. Przepisz klasę z tym rozszerzeniem i sprawdź czy działa:

class WorldZLicznikiem:
    def __init__(self, dt):
        self.time = 0.0
        self.dt = dt
        self.history = [0.0]
        self.step_count = 0  # ← NOWOŚĆ: licznik wywołań

    def step(self):
        self.time += self.dt
        self.history.append(self.time)
        self.step_count += 1  # ← zliczamy każde wywołanie

w = WorldZLicznikiem(dt=0.1)
for _ in range(5):
    w.step()

print("Czas:", w.time)
print("Liczba wywołań step():", w.step_count)
print("Czy są równe?", round(w.time, 5) == round(w.dt * w.step_count, 5))

🟡 Zadanie 4 — Historia

Zmodyfikuj World tak, żeby history zapisywało krotki (numer_kroku, czas):

class WorldZKrotkami:
    def __init__(self, dt):
        self.time = 0.0
        self.dt = dt
        self.history = [(0, 0.0)]  # ← krotka od razu

    def step(self):
        self.time += self.dt
        krok = len(self.history)
        self.history.append((krok, self.time))

w = WorldZKrotkami(dt=0.25)
for _ in range(4):
    w.step()

print("Historia:", w.history)
# Wyciągnij same czasy i sprawdź różnice:
czasy = [t for _, t in w.history]
diffs = [czasy[i+1] - czasy[i] for i in range(len(czasy)-1)]
print("Różnice:", diffs)  # powinny być równe dt

• Czy symulacja działa bez history? Usuń ją z klasy i sprawdź.

🔴 Zadanie 5 — Świat bez fizyki

W tej lekcji świat nie ma: prędkości, przyspieszenia, sił, obiektów.

• Czy to nadal jest poprawna struktura symulacji?
• Napisz klasę World2 z dwoma niezależnymi zegarami: time_fast (dt=0.1) i time_slow (dt=1.0).
• Oba zegary tikają w tym samym step(). Czy to poprawne? Kiedy może być przydatne?

class World2:
    def __init__(self):
        # Uzupełnij: dwa atrybuty time_fast i time_slow
        pass

    def step(self):
        # Uzupełnij: oba zegary tykają w tej samej metodzie
        pass

w2 = World2()
for _ in range(5):
    w2.step()

# Wypisz oba czasy po 5 krokach — co obserwujesz?

🏆 Zadanie mistrzowskie — World to tylko zegar

world1 = World(dt=0.1)
world2 = World(dt=0.2)

for _ in range(100):
    world1.step()
    world2.step()

print(world1.time)
print(world2.time)

Część 1: Czy wyniki zależą od jakiejkolwiek fizyki?

Część 2: Czy istnieje w modelu jakakolwiek zmienna przestrzenna?

Część 3: Udowodnij że World to zegar — napisz klasę Zegar która robi dokładnie to samo bez użycia słowa World, time, dt, step, history. Użyj własnych nazw. Czy zachowanie jest identyczne?

Jeśli potrafisz odpowiedzieć — rozumiesz Lekcję 00 jako fundament całego kursu.

✅ Odpowiedzi — Checklista

1. Tak — World posiada atrybut time, tworzony w __init__ przez self.time = 0.0.
2. Tak — time = 0.0 bo każda symulacja zaczyna od chwili „zero" — jak stoper przed startem wyścigu.
3. Tak — dt jest parametrem konstruktora i zapisywany jako self.dt = dt. Każdy obiekt World może mieć inne dt — jeden świat może tykać co 0.05s, inny co 1.0s.
4. Tak — step() wykonuje dokładnie self.time += self.dt. To jedyna operacja arytmetyczna w całej lekcji.
5. Tak — time jest modyfikowane wyłącznie wewnątrz step(). W żadnym innym miejscu nie piszemy self.time = .... To ważna zasada enkapsulacji.
6. Tak — history to lista []; self.history.append(self.time) dodaje wartość na koniec listy po każdym wywołaniu step().
7. Tak — brak atrybutów: x, y, vx, vy, ax, ay. Świat L00 nie wie nic o przestrzeni — tylko o czasie.
8. Tak — brak listy objects = []. Świat L00 nie zarządza jeszcze żadnymi bytami w przestrzeni.
9. Tak — jedyna zmiana stanu to time += dt i zapis do history. Wszystko inne jest statyczne lub nie istnieje.
10. Tak — World to deterministyczny licznik. Przy tych samych parametrach i tej samej liczbie kroków zawsze daje identyczny wynik. Zero losowości, zero fizyki.
11. dt = stały krok (np. 0.1) — nie zmienia się przez całą symulację. time = aktualny czas — rośnie o dt po każdym step(). Analogia: dt = długość jednego kroku pieszego (np. 70cm), time = całkowita przebyta droga.
12. Przy tych samych 20 krokach: dt=0.05 → czas końcowy 1.0s (gęste punkty, dokładna symulacja). dt=1.0 → czas końcowy 20.0s (rzadkie punkty, zgrubna symulacja). Oba wykonały 20 kroków — ale ich „światy" żyją w różnym tempie.
13. Tak — wystarczy napisać: for _ in range(100): world.step(). Podkreślenie _ zamiast zmiennej i jest konwencją Pythona gdy nie używamy licznika.

🎯 Odpowiedzi — Zadania z charakterem

🟢 Zadanie 1 — Fundament czasu

Tak — świat może istnieć bez ruchu.

Brak dynamiki nie oznacza braku struktury. Klasa World z atrybutami time, dt i metodą step() to w pełni działający system — ma stan, ma zachowanie, żyje w czasie. Po prostu nic jeszcze nie „robi" poza liczeniem czasu.

Zaczynamy od czasu dlatego, że w symulacji fizycznej każda zmiana jest opisana w czasie: pozycja zmienia się co dt sekund, prędkość to zmiana pozycji w czasie, przyspieszenie to zmiana prędkości w czasie. Bez kontrolowanego kroku czasu nie ma sensu mówić o żadnym ruchu.

Analogia: zanim zbudujesz dom, musisz mieć działkę. World to działka — pusta, ale gotowa na budowę.

🟢 Zadanie 2 — Rola dt

dt to rozmiar jednego kroku — stały przez całą symulację, nie zmienia się. time to aktualny czas — rośnie o dt po każdym wywołaniu step().

Analogia z życia: dt to długość jednego kroku pieszego (np. 70cm — każdy krok jest taki sam). time to całkowita przebyta droga (po 10 krokach = 7m, po 100 krokach = 70m).

Jeśli ustawisz dt = 0:

world = World(dt=0)
world.step()
print(world.time)  # → 0.0 — czas nigdy nie rośnie!

Symulacja się kręci, ale czas stoi w miejscu. Martwa symulacja.

dt należy do świata bo to świat odpowiada za rytm symulacji. Obiekt (który dodamy w L01) tylko reaguje na ten rytm — nie wyznacza go. Gdyby każdy obiekt miał własne dt, mogłyby żyć w różnych tempach i nie dałoby się ich zsynchronizować.

🟡 Zadanie 3 — Metoda step()

W L00 step() zmienia wyłącznie time (i history). W L05+ będzie też aktualizować pozycje i prędkości — ale zawsze właśnie w step().

Dwa wywołania step() w jednej turze → czas przeskakuje o 2*dt → fizyka w przyszłych lekcjach się rozjeżdża.

Pełna klasa z licznikiem i weryfikacją:

class WorldZLicznikiem:
    def __init__(self, dt):
        self.time = 0.0
        self.dt = dt
        self.history = [0.0]
        self.step_count = 0  # ← licznik wywołań

    def step(self):
        self.time += self.dt
        self.history.append(self.time)
        self.step_count += 1  # ← zliczamy każde wywołanie

w = WorldZLicznikiem(dt=0.1)
for _ in range(5):
    w.step()

print("Czas:", w.time)                    # → 0.5
print("Wywołań step():", w.step_count)   # → 5
print("Czas == dt × kroki:", round(w.time, 5) == round(w.dt * w.step_count, 5))  # → True

Co by się stało przy dwóch step() w jednej turze?

w2 = WorldZLicznikiem(dt=0.1)
w2.step()
w2.step()  # ← BŁĄD: dwa razy w jednej "turze"
print(w2.time)  # → 0.2 zamiast 0.1 — czas przeskoczył!

🟡 Zadanie 4 — Historia

class World:
    def __init__(self, dt):
        self.time = 0.0
        self.dt = dt
        self.history = [(0, 0.0)]  # ← zaczynamy od krotki, nie od float!

    def step(self):
        self.time += self.dt
        krok = len(self.history)  # numer kroku = długość listy przed append
        self.history.append((krok, self.time))

Symulacja działa bez history — step() nadal zwiększa time. history to narzędzie analityczne, nie dynamiczne.

Wykres prędkości wzrostu (powinien być płaski — stały dt):

# history przechowuje krotki (krok, czas) — wyciągamy sam czas
czasy = [t for _, t in world.history]
diffs = [czasy[i+1] - czasy[i] for i in range(len(czasy)-1)]
print(diffs)  # każda wartość powinna być równa dt
# np. [0.25, 0.25, 0.25, 0.25, ...]

🔴 Zadanie 5 — Świat bez fizyki

To poprawna struktura — uproszczona, ale spójna. Warstwowe budowanie systemów to klucz inżynierii oprogramowania. Każda warstwa robi jedną rzecz dobrze.

class World2:
    def __init__(self):
        self.time_fast = 0.0  # dt = 0.1 — czas fizyczny
        self.time_slow = 0.0  # dt = 1.0 — czas gameplayowy

    def step(self):
        self.time_fast += 0.1
        self.time_slow += 1.0

Dwa zegary w jednym step() to poprawne i przydatne — np. jeden tyka co 0.05s (fizyka: ruch pocisku), drugi co 1.0s (gameplay: tura gracza). To wzorzec stosowany w grach: physics tick vs game tick.

🏆 Zadanie mistrzowskie — World to tylko zegar

Wyniki zależą wyłącznie od dt i liczby kroków. Zero fizyki. Nie ma zmiennej przestrzennej.

class Zegar:
    def __init__(self, krok):
        self.wartosc = 0.0
        self.krok = krok
        self.historia = [0.0]

    def tik(self):
        self.wartosc += self.krok
        self.historia.append(self.wartosc)

Zegar robi identycznie to samo co World. Różni się tylko nazewnictwem. To dowód że World to zegar — nic więcej, nic mniej. Nazwa klasy ≠ jej zachowanie.

World to deterministyczny licznik kroków. Czas w symulacji to umowa, nie prawda absolutna.

🧠 Zasada Profesora

Najpierw definiujesz strukturę świata, dopiero potem pozwalasz mu się poruszać.

Świat to: kontener, organizator, nadrzędna struktura.
Nie: ruch, siła, dynamika.

Jeśli architektura nie istnieje — każda fizyka będzie przypadkiem.

🔥 Złota Myśl

Ruch bez struktury to chaos.
Struktura bez ruchu to potencjał.