Коси хитац¶

Задатак решавамо тако што кретање косог хица разлажемо на хоризонтално кретање које је равномерно кретање са почетном брзином која је једнака хоризонталној компоненти почетне брзине и на вертикално кретање које је равномерно убрзано (тј. успорено) кретање чија је почетна брзина једнака вертикалној компоненти почетне брзине и које је под дејством гравитационог убрзања $g$.

Почетну брзину лако можемо разложити на њену хоризонталну и вертикалну компоненту. Она је задата вектором чији је интензитет $v_0$, и чији је угао у односу на подлогу једнак $\alpha$. Имајући у виду да је $\alpha=45^\circ$ јасно је да су хоризонтална и вертикална компонента странице квадрата ком је вектор почетне брзине дијагонала. Стога је интензитет тих вектора једнак интензитету почетног вектора $v_0$ подељеном са $\sqrt{2}$. Ипак општије решење добијамо применом тригонометрије. Лако се уочава да три вектора брзине чине правоугли троугао, да је вертикална компонента катета која се налази наспрам угла $\alpha$, да је хоризонтална компонента катета која је налегла на угао $\alpha$, а да је почетна брзина хипотенуза. Пошто је синус угла $\alpha$ однос између наспрамне катете и хипотенузе, интензитет вертикалне компоненте можемо израчунати као $v_{0y} = v_0 \sin{\alpha}$. Слично, пошто је косинус угла $\alpha$ однос између налегле катете и хипотенузе, интензитет хоризонталне компоненте можемо израчунати као $v_{0x} = v_0 \cos{\alpha}$. Наравно, меру угла $\alpha$ морамо претворити у радијане (множењем са $\pi$ и дељењем са $180^\circ$ или, још једноставније, библиотечком функцијом math.radians).

Када знамо почетне брзине по свакој компоненти, положај у оба правца (тј. координате центра лоптице) можемо једноставно израчунати. Пошто је кретање дуж хоризонтале равномерно, важи да је $x = v_{0x}t$. Пошто је кретање дуж вертикале равномерно успорено, са гравитационим успорењем $g$, важи да је $y = v_{0y}t - \frac{gt^2}{2}$.

Цео рачун у програму може бити изражен у стандардним мерним јединицама (брзине $v_0$, $v_{0x}$ и $v_{0y}$ можемо изразити у метрима у секунди, убрзање $g$ је стандардно изражено у метрима у секунди за секунду, док се координате $x$ и $y$ могу изразити у метрима). Генерално је веома добар обичај да се у свим физичким симулацијама управо тако ради. Међутим, тада нам остаје проблем прерачунавања координата из стварног света у екранске координате. Желимо да лоптица започне своје кретање од левог краја екрана и да га заврши на десном крају. Да бисмо могли да тако подесимо прерачунавање координата, потребно је да одредимо максимални домет лоптице, тј. даљину на којој ће поново пасти на земљу. То се веома једноставно може одредити из услова да је $y = 0$ тј. $0 = v_{0y}t - \frac{gt^2}{2}$. Једно решење је $t = 0$, јер се у почетку лоптица налази на земљи. Друго решење се, након дељења једанчине са $t$ (под условом да $t$ није једнако нули) добија из услова $v_{0y} = \frac{gt}{2}$. Одатле израчунавамо да је време до пада једнако $\frac{2v_{0y}}{g}$, па је домет једнак $x_{max} = \frac{2v_{0x}v_{0y}}{g}$. Ово је већ довољно да можемо израчунати тражени домет, мада се ова формула може даље свести на $x_{max} = \frac{v_0^2 \cdot (2\sin{\alpha}\cos{\alpha})}{g}$, тј., применом формуле за синус двоструког угла на $x_{max} = \frac{v_0^2\sin{2\alpha}}{g}$. Интересантно, одавде се лако види да се максимални домет достиже за угао $\alpha=45^\circ$ (јер је синус угла увек мањи или једнак 1, а за угао од 45 степени добија се управо вредност 1).

import math

import pygame as pg

import pygamebg

​

(sirina, visina) = (300, 300) # otvaramo prozor

prozor = pygamebg.open_window(sirina, visina, "Коси хитац")

​

g     = 9.81     # gravitaciona konstanta - 9.81 metara u sekundi po sekundi

t     = 0        # đule se ispucava u trenutku t = 0 sekundi

v0    = 10       # pocetna brzina je 10 m/s

alpha = 45       # ugao je 45 stepeni

(x, y) = (0, 0)  # početni položaj je u koordinatnom početku

​

v0x  = v0 * math.cos(math.radians(alpha)) # horizontalna brzina

v0y  = v0 * math.sin(math.radians(alpha)) # vertikalna brzina

xmax = v0x * (2 * v0y / g)                # maksimalni domet

​

dt = 0.01  # vremenski interval između dva susedna frejma

​

def crtaj():

    prozor.fill(pg.Color("white"))  # bojimo pozadinu u belo

    r = 20                          # poluprecnik đuleta

    # preračunavamo iz koordinata sveta u ekranske koordinate

    # za x=0 želimo da je xe=r, a za x=xmax želimo da je xe=sirina-r

    # skaliranje po obe ose treba da bude jednako

    k = (sirina - 2 * r) / xmax

    xe = round(k * x + r)

    ye = round(visina - r - k * y)

    pg.draw.circle(prozor, pg.Color("blue"), (xe, ye), r)  # crtamo đule

​

def novi_frejm():

    global t, x, y  # menjaćemo ove globalne promenljive

    t += dt         # uvećavamo vreme

    if x < xmax:    # ako đule još nije palo

        (x, y) = (v0x * t, v0y * t - g*t**2 / 2) # novi polozaj đuleta

        if y < 0: # ako je đule propalo u zemlju

            (x, y) = (xmax, 0)  # vraćamo ga na površinu

​

pygamebg.frame_loop(round(1/dt), novi_frejm)

​

Слободно бацање¶

Слободно бацање представља коси хитац. Претпоставићемо да се изводи са растојања $d$ од коша и са висине $h$, а да се кош налази на висини $H$. Координатни систем ћемо поставити тако да му је координатни почетак на месту на ком стоји играч који изводи бацање (тада се бацање изводи из тачке $(0, h)$ и треба да се погоди кош који је у тачки (d, H). Пре цртања ћемо вршити трансформацију координата из овог координатног система у координатни систем прозора. Приликом анимације косог хица мењаћемо обе координате све док y координата не достигне вредност $d$ (лопта не дође до коша), након чега ћемо наставити да смањујемо x координату, а да y координату не мењамо (лопта наставља да пада вертикално наниже). Да би се постигао ефекат проласка лоптице кроз кош лоптица треба да буде испред табле, а иза мрежице. Стога смо из слике коша издвојили мрежицу и цртаћемо прво таблу, затим лопту и на крају мрежицу. Када лопта дође до дна екрана (када јој y координата постане 0), на средини екрана ћемо приказати два логотипа.

Угао испуцавања лопте је 52 степена, а ти покушај да погодиш почетну брзину тако да лопта „без коске” прође кроз кош.

import math

import pygame as pg

import pygamebg

​

(sirina, visina) = (800, 480) # otvaramo prozor

prozor = pygamebg.open_window(sirina, visina, "PyGame")

​

kos = pg.image.load('kos.png')

lopta = pg.image.load('lopta.png')

mrezica = pg.image.load('mrezica.png')

petlja = pg.image.load('petlja_logo.png')

pygame = pg.image.load('pygame_logo.png')

​

g     = 9.81     # gravitaciona konstanta - 9.81 metara u sekundi po sekundi

t     = 0        # đule se ispucava u trenutku t = 0 sekundi

v0    = 9.2      # pocetna brzina u metrima po sekundi

alpha = 52       # ugao ispucavanja u stepenima

H = 3            # visina kosa u metrima

h = 1.95         # visina igraca u metrima

d = 7.2          # udaljenost linije slobodnih bacanja u metrima

​

(x, y) = (x0, y0) = (0, h)  # početni položaj je na mestu ispucavanja

v0x  = v0 * math.cos(math.radians(alpha)) # horizontalna brzina

v0y  = v0 * math.sin(math.radians(alpha)) # vertikalna brzina

dt = 0.01  # vremenski interval između dva susedna frejma

​

def crtaj():

    prozor.fill(pg.Color("white"))  # bojimo pozadinu u belo

​

    ppm = 90 # broj piksela po metru

​

    # ekranske koordinate centra kosa

    kos_xe = ppm * d

    kos_ye = visina - ppm * H

​

    # koordinate gornje leve ivice slike kosa

    kos_x0 = kos_xe - (1/3) * kos.get_width()

    kos_y0 = kos_ye - (2/3) * kos.get_height()

​

    # crtamo kos

    prozor.blit(kos, (kos_x0, kos_y0))

​

    # ekranske koordinate centra lopte

    lopta_xe = ppm * x

    lopta_ye = visina - ppm * y

​

    # koordinate gornje leve ivice centra lopte

    lopta_x0 = lopta_xe - lopta.get_width() / 2

    lopta_y0 = lopta_ye - lopta.get_height() / 2

​

    # crtamo loptu

    prozor.blit(lopta, (lopta_x0, lopta_y0))

​

    # crtamo mrezicu

    prozor.blit(mrezica, (kos_x0, kos_y0))

​

    # ako je lopta pala na zemlju

    if y < 0:

        # prikazujemo logo petlje i logo pygame

        prozor.blit(petlja, (sirina / 2 - petlja.get_width() / 2,

                             visina / 2 - petlja.get_height()))

        prozor.blit(pygame, (sirina / 2 - pygame.get_width() / 2,

                             visina / 2))

​

def novi_frejm():

    global t, x, y  # menjaćemo ove globalne promenljive

    t += dt         # uvećavamo vreme

    if x < x0 + d:    # ako lopta nije udarila u tablu

        x = x0 + v0x * t  # pomeramo je nadesno

    y = y0 + v0y * t - g*t**2 / 2  # pomeramo je nadole

    crtaj()

​

# pokrećemo animaciju

pygamebg.frame_loop(round(1/dt), novi_frejm)

​

Кошаркашка лопта која губи енергију¶

Када се лоптица пусти са почетне висине $h_0$ она пада под утицајем гравитације. Слободан пад представља равномерно убрзано кретање тако да је пређени пут у слободном паду после времена $t$ једнак $\frac{gt^2}{2}$, где је $g$ гравитационо убрзање. Висина на којој ће се лоптица налазити након времена $t$ биће једнака $h = h_0 - \frac{gt^2}{2}$.

Када лоптица удари у земљу (када је $h = 0$), тада се кретање мења. Можемо претпоставити да се у том тренутку лоптица испаљује навише са почетног положаја $h_0 = 0$, при чему је почетна брзина негативна и једнака је 75 процената позитивне брзине коју је лоптица имала у тренутку удара о подлогу (заиста, у тренутку удара брзина је усмерена вертикално наниже, док је након одбијања брзина усмерена вертикално навише, па им је знак супротан). Приликом првог удара о подлогу, брзина ће бити једнака $gt$, где је $t$ време које је било потребно да лоптица удари у земљу. Када се лоптица одбије навише, њено кретање је комбинација два кретања. Једно је равномерно и усмерено је навише и одређено је почетном брзином у тренутку одбијања, а друго је слободни пад наниже, под утицајем гравитације. Ако је почетна брзина негативна, тада се пређени пут одбијене лоптице може описати формулом $v_0t + \frac{gt^2}{2}$, па се након времена $t$ она налази на висини $h = -(v_0t + \frac{gt^2}{2})$.

Приметимо да се почетно испуштање лоптице и свако одбијање лоптице заправо могу описати истим формулама. Наиме, у почетку можемо сматрати да се лоптица налази на задатој висини $h_0$, и да јој је почетна брзина $v_0 = 0$, а у наредним одбијањима можемо претпоставити да је почетна висина $h_0 = 0$, а да је почетна брзина једнака оној преосталој после одбијања тј. да је једнака $v_0 = -kv$, где је $k$ коефицијент задржавања енергије (k=0.75 у нашем случају), а $v$ је тренутна брзина у тренутку одбијања и једнака је $v = v_0 + gt$, где је $v_0$ почетна брзина претходног кретања, $g$ гравитациона константа, а $t$ време протекло од почетка претходног кретања до тренутка удара о подлогу (оно се може експлицитно израчунати, али за тим нећемо имати потребе јер ћемо током симулације време одржавати у променљивој $t$, тако да ћемо ту вредност већ имати на располагању у тренутку када приметимо да је $h \leq 0$). Када знамо почетну брзину и висину сваког новог кретања, знамо да ће висина на којој ће се лоптица налазити након времена $t$ бити једнака $h = h_0 - (vt + \frac{gt^2}{2})$.

Симулацију организујемо тако што на почетку постављамо вредност $h_0 = 2$ (јер је у првом кретању лопта на висини од два метра), $v_0 = 0$ (јер лопта нема почетну брзину) и t = 0. Након тога, у телу петље време $t$ увећавамо за по једну стотинку (уједно помоћу pg.time.wait(10) чекамо једну стотинку), израчунавамо висину $h$ на којој се лоптица налази, исцртавамо лоптицу и проверавамо да ли је лоптица додирнута подлогу (да ли је $h \leq 0$). Када лоптица додирне подлогу, започињемо ново кретање тако што постављамо $h = h_0 = 0$, $v_0 = -k(v_0t + gt)$ и тако што враћамо $t = 0$ (јер започиње ново кретање и време меримо из почетка).

Приметимо да је цео рачун у програму био изражен у стандардним мерним јединицама (висине $h_0$ и $h$ су изражене у метрима, време $t$ у секундама, а брзине $v_0$ и $v$ у метрима у секунди за секунду). Генерално је веома добар обичај да се у свим физичким симулацијама управо тако ради. Међутим, тада нам остаје проблем прерачунавања координата из стварног света у екранске координате. Наиме, висина од 2 метра не може бити изражена као 2 пиксела, већ је потребно видети како се она преводи у неки број пиксела који је у вези са висином прозора. Лопту на висини од 2 метра желимо да представимо тако да се налази на самом врху екрана тј. тако да јој горња ивица додирује горњу ивицу прозора. Дакле за $h=2$ желимо да важи да је $y=r$. Лопту на висини од 0 метара желимо да представимо тако да јој доња ивица додирује доњу ивицу екрана. Дакле, за $h=0$ желимо да важи да је $y=visina-r$. Потребно је пронаћи линеарну функцију која пресликава $h$ у $y$ која задовољава ова два услова. Једноставно (на пример, постављањем облика $y=ah+b$, уврштавањем ова два услова и решавању добијеног система по непознатим коефицијентима $a$ и $b$) добијамо да је $y = \frac{2r - visina}{2}h + visina - r$.

Ако би се претходна симулација пустила могло би се приметити да лоптица стално јако мало осцилује око равнотежног положаја. Узрок томе су рачунске грешке до којих неминовно долази када се у рачунару ради са реалним бројевима. Да би се то спречило и да би се лопта у неком тренутку зауставила, можемо вршити проверу њене брзине пре започињања новог хица. Када се примети да је та брзина јако мала, можемо је поставити на нулу и тако зауставити лоптицу.

import pygame as pg

import pygamebg

​

(sirina, visina) = (400, 400) # otvaramo prozor

prozor = pygamebg.open_window(sirina, visina, "Кошаркашка лопта")

​

g  = 9.81  # gravitaciona konstanta - 9.81 metara u sekundi po sekundi

k  = 0.75  # koeficijent elastičnosti

h0 = 2     # početna visina sa koje se baca lopta - 2 metra

v0 = 0     # nema početne brzine

h  = h0    # tekuća visina (položaj lopte)

t = 0      # lopta se baca u trenutku t = 0 sekundi

dt = 0.01  # promena vremena nakon kog se lopta pomera i ponovo crta

​

def crtaj():

    # boje koje cemo koristiti

    BELA = (255, 255, 255)

    NARANDZASTA = (255, 120, 0)

​

    prozor.fill(BELA)   # bela pozadina

    r = 40              # poluprečnik lopte

    # lopta se nalazi horizontalno na sredini prozora, a

    # visina se odredjuje tako da za h=2 vazi y=r, a za h=0 vazi y=visina-r

    (x, y) = (sirina / 2, (2 * r - visina) / 2 * h + visina - r)

    pg.draw.circle(prozor, NARANDZASTA, (round(x), round(y)), r)  # crtamo loptu

​

def novi_frejm():

    global t, h, h0, v0

    t += dt                     # ažuriramo proteklo vreme

    h = h0 - (v0*t + g*t*t/2)   # izracunavamo novu visinu lopte

    if h <= 0:                  # ako je lopta dodirnula zemlju

        v0 = -k*(v0 + g*t)      # izračunavamo novi vektor brzine

        if v0 > -0.2: v0 = 0    #    ako je brzina premala, zaustavljamo odbijanje

        h0 = h = 0              #    započinjemo novi hitac

        t = 0                   #    vreme kreće iz početka

​

pygamebg.frame_loop(round(1/dt), novi_frejm)

​

Клатно¶

Математичко клатно је објекат занемариво мале масе окачен о канап које се клати под дејством гравитационе силе. Клатно се креће дуж кружног лука. Вектор брзине кретања клатна је увек усмерен дуж тангенте на тај кружни лук. Претпоставимо да у неком тренутку клатно заклапа угао $\theta$ са вертикалном осом. Клатно једноставно можемо нацртати на основу дужине конца $l$ и угла $\theta$. Наиме, на основу ових величина лако можемо елементарном тригонометријом израчунати координате клатна, ако знамо координате тачке за коју је оно окачено. Ако су те координате $(c_x, c_y)$, тада се координате могу израчунати са $x = c_x + l\sin{\theta}$, $y = c_y + l\cos{\theta}$ (јер екранска координата y расте навише).

На клатно делује гравитациона сила, вертикално у смеру подлоге, чији је интензитет $mg$, где је $m$ маса клатна, а $g$ гравитационо убрзање. Та сила се може разложити на компоненту која делује у правцу конопца (под углом $\theta$ у односу на вертикалу) и на компоненту која делује дуж нормале на тај правац. Прва компонента гравитационе силе се поништава силом затезања конопца тако да се клатно не креће горе доле дуж правца конопца. За клаћење је релевантна друга компонента силе која покреће клатно лево-десно и делује дуж брзине његовог кретања (тангенцијално у односу на кружни лук дуж ког се клатно креће). Интензитет те компоненте гравитационе силе је $mg\sin{\theta}$. На основу другог Њутновог закона важи да је укупна сила која делује на неки објекат једнака производу његове масе и убрзања, одакле следи да је убрзање клатна $a = -g\sin{\theta}$. Знак минус је потребан због тога што је убрзање увек усмерено супротно од угла $\theta$ (заиста, ако је клатно на левој страни, јасно је да га убрзање вуче постепено на десно и обратно).

Претпоставимо да је $\theta$ дат у радијанима. Промени угла од $d\theta$ радијана одговара пређени пут клатна у дужини од $ds = l\cdot d\theta$. Угаона брзина клатна $v_\theta$ мери промену угла у јединици времена. На основу претходног, важи да је $v_\theta = l \cdot v$. Слично, угаоно убрзање клатна $a_\theta$ мери промену угаоне брзине у јединици времена и на основу претходног важи да је $a_\theta = l \cdot a$. Одатле следи да је $l\cdot a_\theta = -g\sin{\theta}$. Ово је једначина која прецизно описује кретање нашег клатна и на основу ње се може извршити прецизна симулација кретања тог клатна. Пошто се у једначини истовремено јављају и нека непозната функција (у нашем случају функција која описује угао $\theta$ у зависности од времена) и брзине њене промене, тзв. изводи (у нашем случају то је функција која описује угаоно убрзање $a_\theta$ у зависности од времена), у питању је диференцијална једначина (мада представљају основу физике, о њима ћеш, нажалост, учити тек нешто мало у вишим разредима гимназије).

У сваком тренутку знамо тренутни угао које клатно заузима и знамо тренутну угаону брзину (у почетку можемо претпоставити да је клатно испуштено са неког угла $\theta_0$, без почетне угаоне брзине). На основу угла, можемо израчунати угаоно убрзање као $a_\theta = -\frac{g}{l}\sin{\theta}$. На основу тог убрзања можемо одредити нову угаону брзину. Наиме, ако је време $dt$ у ком се мери промена мало, можемо претпоставити да ће веза бити линеарна, тј. да ће се угаона брзина променити за $a_\theta \cdot dt$. Слично, када знамо угаону брзину, ако је је време $dt$ мало, можемо претпоставити да ће веза између промене угла и угаоне брзине такође бити линеарна, па добијамо да се угао мења за $v_\theta \cdot dt$. На основу тога израчунавамо нови положај клатна (једнозначно одређен углом), цртамо клатно и даље симулацију настављамо по потпуно истом принципу. Овакав начин одређивања решења се обично приписује чувеном математичару Ојлерову и назива се Ојлерова метода.

Иако је претходни приступ сасвим довољан да се направи симулација кретања клатна (што је $dt$ мање, то је симулација прецизнија, а постоје и нумеричке методе, попут фамилије метода Рунге-Кута, да се кретање још прецизније процени), физичари су трагали за формулама којима би се кретање клатна експлицитно описало. Нажалост, диференцијална једначина клатна се не може решити тако да се пронађе елементарна веза између угла и времена. Ипак, може се употребити мали трик који упрошћава једначину и омогућава њено експлицитно решавање. Наиме, ако је угао $\theta$ мали (по апсолутној вредности не већи од 15 степени), важи да је $\sin{\theta}$ приближно једнако $\theta$. Заменом прве величине другом добијамо да је $a_\theta = -\frac{g}{l}\theta$. Овим се добија једначина која се се прилично једноставно може решити и добија се решење $\theta = \theta_0 \cos{\sqrt{\frac{g}{l}}t}$. Заиста, за $t=0$ важи да је $\theta = \theta_0$, тј. клатно се налази у почетном положају. Угаона брзина се тада израчунава као $v_\theta = -\theta_0 \sqrt{\frac{g}{l}} \sin{\sqrt{\frac{g}{l}}t}$. Угаоно убрзање се тада израчунава као $a_\theta = -\theta_0 \sqrt{\frac{g}{l}} \sqrt{\frac{g}{l}} \cos{\sqrt{\frac{g}{l}}t}$, тј. као $a_\theta = -\frac{g}{l} \theta_0 \cos{\sqrt{\frac{g}{l}}t} = -\frac{g}{l}\theta$, тако да је упрошћена једначина задовољена.

Упрошћену једначину можемо решавати и нумерички (симулацијом, на потпуно исти начин на који смо решавали и праву једначину), а можемо и просто само исцртавати њено решење. Тако у програму добијамо три клатна - једно, црно, које стварно одговара кретању клатна у природи и два, црвено и зелено, која то раде само приближно. Покретањем симулације може се јасно видети разлика између правог кретања клатна и његове апроксимације. Видимо и да постоји мала разлика између експлицитног решења упрошћене једначине (зеленог) и оног добијеног нумеричком симулацијом (црвеног), међутим, да су та два решења доста блиска, тј. да грешка симулације није велика, иако је коришћена најједноставнија могућа Ојлерова метода.

import math

import pygame as pg

import pygamebg

​

(sirina, visina) = (400, 400) # otvaramo prozor

prozor = pygamebg.open_window(sirina, visina, "Клатно")

​

# mesto gde je klatno zakaceno

(cx, cy) = (sirina / 2, 0)

# gravitaciona konstanta u (m/s^2)

g = 9.81

# duzina klatna (u m)

l = 0.2

# pocetno vreme (u s)

t = 0

# promena vremena (u s)

dt = 0.01

​

# početni ugao otklona klatna (ujedno i maksimalni)

theta_max = math.radians(15)

# trenutni ugao kada se izračunava po stvarnim formulama

klatno_theta = theta_max

# trenutni ugao kada se izračunava po uproscenim formulama

klatno_uprosceno_theta = theta_max

# trenutni ugao kada se izračunava po eksplicitnim formulama

klatno_eksplicitno_theta = theta_max

​

# pocetna brzina

v0 = 0

# trenutna brzina kada se izračunava po stvarnim formulama

klatno_v_theta = v0

# trenutna brzina kada se izračunava po uproscenim formulama

klatno_uprosceno_v_theta = v0

​

# crtanje klatna u datoj boji, na datom uglu

def nacrtaj_klatno(theta, boja):

    # broj piksela po metru (faktor zumiranja)

    ppm = 1000

    # poluprečnik loptica u pikselima

    r = 15

    # polozaj tačke izračunavamo na osnovu ugla

    x = cx + ppm*l*math.sin(theta)

    y = cy + ppm*l*math.cos(theta)

    # crtamo crno klatno

    pg.draw.line(prozor, boja, (cx, cy), (x, y), 1)

    pg.draw.circle(prozor, boja, (round(x), round(y)), r)

​

def crtaj():

    # bojimo pozadinu prozora u belo

    prozor.fill(pg.Color("white"))

​

    nacrtaj_klatno(klatno_theta, pg.Color("black"))

    nacrtaj_klatno(klatno_uprosceno_theta, pg.Color("red"))

    nacrtaj_klatno(klatno_eksplicitno_theta, pg.Color("green"))

​

def novi_frejm():

    global t

    global klatno_a_theta, klatno_v_theta, klatno_theta

    global klatno_uprosceno_a_theta, klatno_uprosceno_v_theta, klatno_uprosceno_theta

    global klatno_eksplicitno_theta

​

    # vreme se menja na osnovu datog priraštaja

    t += dt

​

    # klatno izračunato na osnovu stvarnih formula

​

    # ugaono ubrzanje - stvarna formula

    klatno_a_theta = -(g/l) * math.sin(klatno_theta)

    # ugaona brzina se menja na osnovu ugaonog ubrzanja

    klatno_v_theta += klatno_a_theta * dt

    # ugao se menja na osnovu ugaone brzine

    klatno_theta += klatno_v_theta * dt

​

    # klatno izračunato na osnovu uprošćenih formula

​

    # ugaono ubrzanje - uprošćena formula (sin(theta) je približno theta)

    klatno_uprosceno_a_theta = -(g/l) * klatno_uprosceno_theta

    # ugaona brzina se menja na osnovu ugaonog ubrzanja

    klatno_uprosceno_v_theta += klatno_uprosceno_a_theta * dt

    # ugao se menja na osnovu ugaone brzine

    klatno_uprosceno_theta += klatno_uprosceno_v_theta * dt

​

    # klatno na osnovu eksplicitne jednace kretanja koja se dobija

    # uprošćavanjem formula

​

    # ugao izračunat na osnovu eksplicitne formule

    klatno_eksplicitno_theta = theta_max * math.cos(math.sqrt(g/l)*t)

​

pygamebg.frame_loop(round(1/dt), novi_frejm)

​