def srodek_masy(self):
srodek_masy = Wektor(0.0, 0.0, 0.0)
for i in range(self.ilosc):
srodek_masy += self.punkty[i].polozenie
srodek_masy /= self.ilosc
return srodek_masy
def przygotuj_ruch_verlet(self, przyspieszenie=Wektor(), krok_czasowy=0.0):
if self.numer_kroku == 0:
self.przygotuj_ruch_euler(przyspieszenie, krok_czasowy)
else:
self.nastepne_polozenie = self.polozenie * 2.0 - self.poprzednie_polozenie + przyspieszenie * krok_czasowy**2
self.nastepna_predkosc = (self.nastepne_polozenie -
self.poprzednie_polozenie) / (
2.0 * krok_czasowy)
def obsluz_klawiature(self):
if scene.kb.keys:
s = scene.kb.getkey() # get keyboard info
zpm = self.zpms[0]
zmiana_polozenia = 0.1
if s == 'e':
self.trzymany_punkt.polozenie += Wektor(0, zmiana_polozenia, 0)
if s == 'q':
self.trzymany_punkt.polozenie += Wektor(
0, -zmiana_polozenia, 0)
if s == 'a':
self.trzymany_punkt.polozenie += Wektor(
-zmiana_polozenia, 0, 0)
if s == 'd':
self.trzymany_punkt.polozenie += Wektor(zmiana_polozenia, 0, 0)
if s == 'w':
self.trzymany_punkt.polozenie += Wektor(
0, 0, -zmiana_polozenia)
if s == 's':
self.trzymany_punkt.polozenie += Wektor(0, 0, zmiana_polozenia)
if s == 'x':
# skok
self.trzymany_punkt.predkosc += Wektor(0, -200, 0)
if s == 'm':
zpm.ustaw_wiezy(self.trzymany_punkt.indeks,
not zpm.wiezy[self.trzymany_punkt.indeks])
nums = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
if s in nums:
print(s)
#zpm.ustaw_wiezy(int(s), not zpm.wiezy[int(s)])
self.trzymany_punkt = zpm.pobierz_punkt_materialny(int(s))
self.trzymany_punkt.indeks = int(s)
pass
def zeruj_predkosc_srednia(self):
ilosc_z_wiezami = 0
predkosc_srednia = Wektor(0.0, 0.0, 0.0)
for i in range(self.ilosc):
if self.wiezy[i] is False:
predkosc_srednia += self.pobierz_punkt_materialny(i).predkosc
else:
ilosc_z_wiezami += 1
predkosc_srednia /= (self.ilosc - ilosc_z_wiezami)
def przygotuj_ruch(self,
sila=Wektor(),
krok_czasowy=0.0,
algorytm=Algorytm.EULER):
przyspieszenie = sila / self.masa
if algorytm == Algorytm.EULER:
self.przygotuj_ruch_euler(przyspieszenie, krok_czasowy)
elif algorytm == Algorytm.VERLET:
self.przygotuj_ruch_verlet(przyspieszenie, krok_czasowy)
def __init__(self,
polozenie=Wektor(),
predkosc=Wektor(),
masa=1.0,
promien=0.1,
kolor=Kolor()):
self.polozenie = polozenie
self.predkosc = predkosc
self.poprzednie_polozenie = Wektor()
self.nastepne_polozenie = Wektor()
self.nastepna_predkosc = Wektor()
self.masa = masa
self.promien = promien
self.kolor = kolor
self.sphere = sphere(
radius=self.promien,
pos=[self.polozenie.x, self.polozenie.y, self.polozenie.z],
color=[self.kolor.r, self.kolor.g, self.kolor.b])
self.do_usuniecia = False
def przygotuj_ruch_przy_kontakcie_z_obszarem_zabronionym(
self, indeks, krok_czasowy):
if self.obszar_zabroniony is None:
return
punkt = self.pobierz_punkt_materialny(indeks)
normalna = Wektor()
# Zakladamy, ze nastepne polozenie jest juz obliczone
w_obszarze_zabronionym, normalna = self.obszar_zabroniony.czy_w_obszarze_zabronionym(
punkt.nastepne_polozenie, punkt.polozenie, punkt.promien, normalna)
if w_obszarze_zabronionym:
# Eliminacja skladowej normalnej sily
sila = self.sila(indeks)
skladowa_normalna_sily = normalna * sila
if skladowa_normalna_sily < 0: # usuwanie skladowej sily skierowanej do powierzchni
sila -= normalna * skladowa_normalna_sily # dzialanie sily kontaktowej
# uwzglednienie odbicia (zmiana aktualnego wektora predkosci)
predkosc = punkt.predkosc
skladowa_normalna_predkosci = normalna * predkosc
if skladowa_normalna_predkosci < 0: # usuwanie skladowej predkosci skierowanej do powierzchni
predkosc -= normalna * (
(self.obszar_zabroniony.wspolczynnik_odbicia + 1) *
skladowa_normalna_predkosci)
punkt.ustaw_predkosc(predkosc)
#tarcie
if skladowa_normalna_sily < 0 and predkosc.dlugosc() > 0:
tarcie = predkosc * -1
tarcie.normuj()
tarcie *= math.fabs(
self.obszar_zabroniony.wspolczynnik_tarcia *
skladowa_normalna_sily)
sila += tarcie
# ponowne przygotowanie ruchu z nowymi sila i predkoscia
# musi byc metoda Eulera, bo ta widzi zmiane predkosci
punkt.przygotuj_ruch(sila, krok_czasowy, algorytm=Algorytm.EULER)
def ustaw_wiezy(self, indeks, ustalona_pozycja):
if indeks >= 0 and indeks < self.ilosc:
self.wiezy[indeks] = ustalona_pozycja
self.punkty[indeks].ustaw_predkosc(Wektor(0, 0, 0))
def ustaw_predkosc(self, predkosc=Wektor()):
self.predkosc = predkosc
def ustaw_polozenie(self, polozenie=Wektor()):
self.polozenie = polozenie
def sila(self, i):
return Wektor()
def przygotuj_ruch_euler(self, przyspieszenie=Wektor(), krok_czasowy=0.0):
self.nastepna_predkosc = self.predkosc + przyspieszenie * krok_czasowy
self.nastepne_polozenie = self.polozenie + self.nastepna_predkosc * krok_czasowy