Ten artykuł wyjaśnia szczegółowo działanie interaktywnej symulacji masy poruszającej się pod wpływem grawitacji, siły wiatru, odbić i tarcia. Skrypt wykorzystuje bibliotekę Matplotlib oraz interfejs Tkinter do stworzenia graficznej symulacji i wizualizacji danych fizycznych w czasie rzeczywistym.

```python g = 9.81 # Przyspieszenie ziemskie (m/s^2) m = 0.15 # Masa kulki (kg) restitution = 0.7 # Współczynnik sprężystości time_step = 0.05 # Krok czasowy (s) friction_coefficient = 0.5 # Współczynnik tarcia ```

Podstawowe stałe fizyczne zostały zdefiniowane na początku. Przyspieszenie ziemskie \( g = 9.81 \, \text{m/s}^2 \), a masa kulki \( m = 0.15 \, \text{kg} \).

Współczynnik sprężystości odpowiada za sposób odbicia od podłoża:

$$ v_{\text{po odbiciu}} = -v_{\text{przed odbiciem}} \cdot \text{restitution} $$

```python ax_acc = Fw / m # Przyspieszenie poziome od wiatru ay_acc = -g # Przyspieszenie pionowe (grawitacja)

vx += ax_acc * time_step vy += ay_acc * time_step

x += vx * time_step + 0.5 * ax_acc * time_step2 y += vy * time_step + 0.5 * ay_acc * time_step2 ```

Tutaj zastosowano klasyczne równania kinematyki:

$$ a_x = \frac{F_{\text{wiatr}}}{m}, \quad a_y = -g $$

$$ v = v_0 + a \cdot \Delta t $$

$$ x = x_0 + v \cdot \Delta t + \frac{1}{2} a \cdot \Delta t^2 $$

```python if y ⇐ y_min:

  y = y_min
  vy = -vy * restitution
  if abs(vy) < 0.5:
      friction_acc = friction_coefficient * g
      ...

```

Gdy kulka uderza o ziemię, odwracana jest pionowa składowa prędkości i zmniejszana zgodnie z:

$$ v_y' = -v_y \cdot \text{restitution} $$

Jeśli prędkość pionowa jest mała, działa tarcie kinetyczne:

$$ F_{\text{tarcie}} = \mu \cdot m \cdot g $$

Co daje przyspieszenie hamujące:

$$ a_{\text{tarcie}} = \mu \cdot g $$

```python g_vector = draw_arrow(x, y, 0, -1, 'blue') wind_vector = draw_arrow(x, y, wind_force, 0, 'green') resultant_vector = draw_arrow(x, y, vx * velocity_scale, vy * velocity_scale, 'purple') ```

Strzałki reprezentują:

• siłę grawitacji – zawsze skierowaną w dół,
• siłę wiatru – poziomą,
• wektor prędkości – skalowaną wartość prędkości całkowitej.

Każdy wektor może być analizowany za pomocą równań składowych lub w zapisie biegunowym:

$$ |\vec{v}| = \sqrt{v_x^2 + v_y^2}, \quad \theta = \arctan\left(\frac{v_y}{v_x}\right) $$

Dwa dodatkowe wykresy pokazują zmiany wartości w czasie:

• prędkość całkowita: \( v = \sqrt{v_x^2 + v_y^2} \)
• przyspieszenie całkowite: \( a = \sqrt{a_x^2 + a_y^2} \)

```python line_speed.set_data(time_list, speed_list) line_acc.set_data(time_list, acc_list) ```

```python draw_polar_arrow(polar_ax, gravity_angle, gravity_magnitude, 'blue', 'Gravity') draw_polar_arrow(polar_ax, wind_angle, wind_magnitude, 'green', 'Wind') draw_polar_arrow(polar_ax, velocity_angle, velocity_magnitude, 'purple', 'Velocity') ```

Wykres biegunowy przedstawia kierunki i wartości wektorów sił oraz prędkości.

Zastosowanie układu biegunowego ułatwia analizę zależności kierunkowych między siłami i ruchem.

```python wind_slider = tk.Scale(…, command=update_wind) spring_slider = tk.Scale(…, command=update_spring) ```

GUI umożliwia użytkownikowi interaktywne sterowanie:

• siłą wiatru (od -2 do 2 N),
• współczynnikiem sprężystości (od 0 do 1),
• restartowaniem symulacji.

Symulacja umożliwia dynamiczną analizę ruchu ciała w polu sił z uwzględnieniem podstawowych praw fizyki:

• II zasada dynamiki Newtona: \( \vec{F} = m \vec{a} \)
• Zasady kinematyki dla ruchu jednostajnie zmiennego
• Prawo odbicia i tarcia dynamicznego

Kod stanowi przykład połączenia symulacji fizycznej, wizualizacji danych oraz interfejsu użytkownika.