Losowanie zdarzeń z jednakowym prawdopodobieństwem

[Benek]

Kod: [Zaznacz]

//wartość cell1 = * * 0

event krosowo multiple 0.0 none
krosowo1
krosowo2
krosowo3
krosowo_losuj
endevent

event krosowo1 multiple 0.0 cell1
krosowo_1
condition memcompare * * 0 endevent

event krosowo_1 multiple 0.0 none
krosowo_zwr13-
krosowo_o_s13
change1_cell1
condition propability 0.3 endevent

event krosowo4 multiple 0.0 cell1
krosowo-wyjazd_j_s2
condition memcompare * * 1 endevent

event krosowo2 multiple 0.0 cell1
krosowo_2
condition memcompare * * 0 endevent

event krosowo_2 multiple 0.0 none
krosowo_zwr13-
krosowo_o_s10
krosowo-wyjazd_j_s2
change2_cell1
condition propability 0.3 endevent

event krosowo3 multiple 0.0 cell1
krosowo_3
condition memcompare * * 0 endevent

event krosowo_3 multiple 0.0 none
krosowo_zwr04a-
krosowo_zwr06a-
krosowo_o_s4
krosowo-wyjazd_k_s10
change2_cell1
condition propability 0.3 endevent

event krosowo_losuj multiple 0.0 cell1
krosowo
condition memcompare * * 0 endevent
Siedzę już kolejną godzinę i kombinuję z ideą losowania. Coś jest nadal nie tak. Przed chwilą załączyły mi się dwa eventy na raz: krosowo1 oraz krosowo3. krosowo4 jest tylko przedłużeniem krosowo1.

changex_cell1

oznacza, że w komórkę cell1 wpisujemy wartość * * x.

[Quark-t]

Zapewne nic to nie da, ale (z matematycznego punktu widzenia) prawdopodobieństwa nie sumują Ci się do 1 (tak ma być?)
Co masz w changeX_cell?

[Benek]

Nie, to nie ma znaczenia. Ten zapis mówi tylko tyle, że jak exe (czy co to tam liczy) wylosuje <0.3, a losuje na przedziale [0,1], to event się wykona. Mam też inne eventy, np.:

Kod: [Zaznacz]

event KeyCtrl01 multiple 10.0 none
dzierzawa1
dzierzawa2
dzierzawa_zwr01-
endevent

event dzierzawa1 multiple 0.0 none
change1_cell1
dzierzawa_zwr01-
dzierzawa_o02_sz1
condition propability 0.5 endevent

event dzierzawa2 multiple 0.0 cell1
dzierzawa_zwr01-
dzierzawa_o02_s10
change1_cell1
condition memcompare * * 0 endeventI w tym przypadku wywołuje się poprawnie raz S10, raz zastępczy, mimo że sumuje się P(A) do 0,5.
Libertyn zasugerował, że można dać opóźnienia czasowe. Jednak z tego co ja wiem, nic to nie powinno dać, gdyż eventy się wykonują po kolei.

event change1_cell1 updatevalues 0.0 cell1 * * 1 endevent

[Quark-t]

Mnie bardziej chodziło o to, że wykonały Ci się dwa na raz, mimo iż jest memcompare. Stąd pytanie o ten changex_cell (w jednym masz change1_cell1, a w drugim i trzecim change2_cell1, czy oba te eventy są ok).

[Ra]

A możesz dać log z tego, co się źle wykonuje?

[Benek]

Quark, oba te eventy są ok.
Przejechałem raz jeszcze. Teraz załączył się sam event krosowo1 i wszystko poszło poprawnie. Jak mam przesłać loga? Waży za dużo.

Coś jednak jest nie halo z tymi zdarzeniami prawdopodobieństwa. Wcześniej przelatuję przez dwie stacje i mimo, że mam ustawione po dwa alternatywne zdarzenia dla każdej ze stacji, z prawdopodobieństwem 0,5, to jednak ciągle się wywołują te same: rabinow1 i malelasy1, fragment kodu:

Kod: [Zaznacz]

// wartość cell1 = * * 1

event rabinow1 multiple 0.0 none
rabinow_q_s5
change2_cell1
condition propability 0.5 endevent

event change2_cell1 updatevalues 0.0 cell1 * * 2 endevent

event rabinow2 multiple 0.0 cell1
rabinow_q_s2
rabinow_h_s2
change3_cell1
condition memcompare * * 1 endevent

event change3_cell1 updatevalues 0.0 cell1 * * 3 endevent

event rabinow3 multiple 0.0 cell1
rabinow_h_s2
change3_cell1
condition memcompare * * 2 endevent

//wartość cell1 = * * 3

event malelasy1 multiple 0.0 none
malelasy_b3_s5
change4_cell1
condition propability 0.5 endevent

event change4_cell1 updatevalues 0.0 cell1 * * 4 endevent

event malelasy2 multiple 0.0 cell1
malelasy_b3_s2
malelasy_b2_s2
change0_cell1
condition memcompare * * 3 endevent

event malelasy3 multiple 0.0 cell1
malelasy_b2_sz1
change0_cell1
condition memcompare * * 4 endevent

event change0_cell1 updatevalues 0.0 cell1 * * 0 endevent

rabinow3 i malelasy3 są kontynuacjami rabinow1 i malelasy1. Natomiast wywołały się alternatywne zdarzenia wtedy, gdy w propability ustawiłem zera. Czyli zachodzą, ale jakoś na 10 odpaleń scenariusza ani razu nie chciały zaskoczyć, gdy były na 0,5...

[AtapiCl]

Przed chwilą załączyły mi się dwa eventy na raz: krosowo1 oraz krosowo3.

No... A wg Ciebie jak powinno być?

[Ra]

Jak mam przesłać loga? Waży za dużo.

Tylko od wyzwolenia pierwszego eventu do wykonania ostatniego z interesujących.

[Benek]

No... A wg Ciebie jak powinno być?

Krosowo1 powinno się załączyć, a krosowo3 już nie. Dlatego, że krosowo1 zmienia wartość w komórce. Poza tym raz mi się załączyło samo krosowo1, a raz oba. Jak to wytłumaczysz?
Wiesz do czego dążę, więc jak możesz to powiedz mi co jest źle po prostu. Sam sugerowałeś mi takie rozwiązanie tego problemu. Widać diabeł tkwi w szczegółach.
W załączeniu log.

Jak to wytłumaczysz?

Chyba jedynie tak, że krosowo tak czy siak uruchomi każdy z subeventów... Tylko dlaczego zabezpieczenie komórką nie pomaga? Nie powinno być tak, że zdarzenia uruchamiają się po kolei? Najpierw krosowo1, potem wszystkie jego subeventy, następnie krosowo2, itd. ?

[AtapiCl]

Mistrzu, a kiedy wg Ciebie zmienia się wartość tej komórki? Bo chyba się pomyliłeś... Pozostałe eventy uruchomią się przed zmianą tej wartości. Wywołany taki event od razu dodaje się na koniec kolejki (EVENT ADDED TO QUEUE). I dopiero jak ta kolejka dojdzie do tego eventu, to on się wykona. A te poprzednie eventy stoją w kolejce przed updatem komórki.

To zadziała tylko wtedy, gdy pozostałe eventy (krosowo2,3) mają zwłokę czasową (z tym, że zwłoka każdego kolejnego eventu musi być wyższa od poprzedniego).

[Benek]

Kod: [Zaznacz]

//wartość cell1 = * * 0

event krosowo multiple 0.0 none
krosowo1
krosowo2
krosowo3
krosowo_losuj
endevent

event krosowo1 multiple 0.0 cell1
krosowo_1
condition memcompare * * 0 endevent

event krosowo_1 multiple 0.0 none
krosowo_zwr13-
krosowo_o_s13
change1_cell1
condition propability 0.3 endevent

event krosowo4 multiple 0.0 cell1
krosowo-wyjazd_j_s2
condition memcompare * * 1 endevent

event krosowo2 multiple 1.0 cell1
krosowo_2
condition memcompare * * 0 endevent

event krosowo_2 multiple 0.0 none
krosowo_zwr13-
krosowo_o_s10
krosowo-wyjazd_j_s2
change2_cell1
condition propability 0.3 endevent

event krosowo3 multiple 2.0 cell1
krosowo_3
condition memcompare * * 0 endevent

event krosowo_3 multiple 0.0 none
krosowo_zwr04a-
krosowo_zwr06a-
krosowo_o_s4
krosowo-wyjazd_k_s10
change2_cell1
condition propability 0.3 endevent

event krosowo_losuj multiple 4.0 cell1
krosowo
condition memcompare * * 0 endeventTeraz jest ok? Ta z ciekawości zapytam czy opóźnienia: 0.001, 0.002, 0.003 też by zdały egzamin. Tzn. czy event potrzebuje czas, aby się wykonać?

Mistrzu, a kiedy wg Ciebie zmienia się wartość tej komórki? Bo chyba się pomyliłeś...

No właśnie, dla mnie to nie było jasne. To nie powód do oburzenia ;)

[AtapiCl]

Ja się nie oburzyłem :)

z ciekawości zapytam czy opóźnienia: 0.001, 0.002, 0.003 też by zdały egzamin. Tzn. czy event potrzebuje czas, aby się wykonać?

Wszystko zależy od sprzętu. Teoretycznie powinien, w praktyce bywa różnie i lepiej dawać większe odstępy.

[libertyn89]

A nie bylo przypadkiem na starszych egzekach bledu obliczania podlogi z delay? Wowczas 0 czy 0,1 nie robiloby zadnej roznicy.

[Ra]

Było rzutowanie na int, zrobione funkcją/makrem abs().

[Benek]

Jeszcze utrudniłem zadanie i widzę po logu, że coś jest nie halo. Dlaczego utrudniłem zadanie? Bo najeżdżamy na odcinek kiblem (3 człony).

Kod: [Zaznacz]

event losuj_sandomierz multiple 0.0 cell1
change0_cell1
sandomierz1
sandomierz2
sandomierz3
sandomierz4
losuj_sandomierz1
condition memcompare * * 1 endevent

event change0_cell1 updatevalues 0.0 cell1 * * 0 endevent

event zwrotki_sandomierz multiple 0.0 none
anglik99ac
zwr104-
anglik90bc
anglik96ac
endevent

event sandomierz1 multiple 0.0 none
change1_cell1
zwrotki_sandomierz
sandomierz_a2_s10
condition propability 0.25 endevent

event sandomierz2 multiple 1.0 cell1
sandomierz2.1
condition memcompare * * 0 endevent

event sandomierz2.1 multiple 0.0 none
change1_cell1
sandomierz2.2
condition propability 0.25 endevent

event sandomierz2.2 multiple 30.0 none
zwrotki_sandomierz
sandomierz_a2_s10
endevent

event sandomierz3 multiple 2.0 cell1
sandomierz3.1
condition memcompare * * 0 endevent

event sandomierz3.1 multiple 0.0 none
change1_cell1
sandomierz3.2
condition propability 0.25 endevent

event sandomierz3.2 multiple 0.0 none
zwrotki_sandomierz
sandomierz_a2_sz1
endevent

event sandomierz4 multiple 3.0 cell1
sandomierz4.1
condition memcompare * * 0 endevent

event sandomierz4.1 multiple 30.0 none
change1_cell1
sandomierz4.2
condition propability 0.25 endevent

event sandomierz4.2 multiple 30.0 none
zwrotki_sandomierz
sandomierz_a2_sz1
endevent

event losuj_sandomierz1 multiple 4.0 cell1
losuj_sandomierz
condition memcompare * * 0 endevent

Chodzi o to, żeby się zabezpieczyć przed losowanie kolejnym członem. Na L144 robiłem coś takiego, ale tam miałem dwa zdarzenia, z czego pierwsze losowałem z prawdopodobieństwem 0.5, a jak nie poszło to wykonywał się alternatywny event, który był eventem pewnym.

[Quark-t]

Propozycja (jeżeli tego nie zrobiłeś, wybacz, nie mam siły się teraz w to wczytywać i szukać) – dodaj komórkę pamięci "buforową", czyli mającą wartość np. 0 0 i event, który zmienia jej wartość i wywołuje event właściwy pod warunkiem stanu początkowego tejże komórki (memcompare * 0 0). Czyli pierwszy człon zmieni na 0 1 i wywoła event właściwy, a drugi człon już nie wywoła nic, bo w komórce będzie 0 1. Jeżeli sytuacja taka ma mieć miejsce kilka razy w czasie trwania scenariusza, to dodaj gdzieś unikalny event przywracający wartość startową komórki pamięci.

[Benek]

Problem jest taki: wywołać kilka zdarzeń z jednakowym prawdopodobieństwem, ale przez więcej niż jeden z członów. Dla prostoty weźmy tylko dwa zdarzenia z prawdopodobieństwem 0.5 i pracujmy na schemacie:

Najeżdżamy pojazdem z więcej niż jednym członem. cell1 ma wartość * * 0, a change1_cell1 zamienia tą wartość na * * 1. W ten sposób zabezpieczamy się przed wywołaniem eventu przez więcej niż 1 człon:

Kod: [Zaznacz]

event zdarzenie1 multiple 0.0 cell1
change1_cell1
start
condition memcompare * * 0 endevent

Następnie przechodzimy do start, które to ma dwa alternatywne zdarzenia oraz zdarzenie zapętlające w razie niewykonania się żadnego ze zdarzeń alternatywnych. Daje opóźnienie 1 sekundowe w razie cuś:

Kod: [Zaznacz]

event start multiple 1.0 none
zdarzenie1
zdarzenie2
petla
endevent

Kolejnym zadaniem jest wylosowanie zdarzenie1 lub zdarzenie2. Jeśli takie zdarzenie zostanie wylosowane, to warto dać o tym znać poprzez komórkę pamięci. Oczywiście dajemy zwłokę czasową. Wspomagamy się zdarzeniami zdarzenie1.1 i zdarzenie2.1. change0_cell1 zmienia wartość komórki cell1 na * * 0:

Kod: [Zaznacz]

event zdarzenie1 multiple 2.0 cell1
zdarzenie1.1
condition memcompare * * 1 endevent

event zdarzenie1.1 multiple 0.0 none
change0_cell1
sem_A_s2
condition propability 0.5 endevent

Analogicznie dla zdarzenie2:

Kod: [Zaznacz]

event zdarzenie2 multiple 3.0 cell1
zdarzenie2.1
condition memcompare * * 1 endevent

event zdarzenie2.1 multiple 0.0 none
change0_cell1
sem_A_s5
condition propability 0.5 endevent

Teraz zdarzenie zapętlające. Musimy najpierw sprawdzić czy zaszło którekolwiek z dwóch alternatywnych zdarzeń. Pamiętamy o opóźnieniu:

Kod: [Zaznacz]

event petla multiple 4.0 cell1
start
condition memcompare * * 1 endevent

Czy to ma sens? Zrobiłem analogicznie i log wg mnie pokazuje zupełnie inaczej niż powinien...

[youBy]

Jeśli dotyczy to tylko jednego składu i tylko jeden raz na uruchomienie, to można losować zawartość komórek pamięci na początku i mieć spokój do końca służby. Co prawda losowość nie będzie w ostatniej chwili, tylko ustalona przy uruchomieniu, ale większość nie zauważy, a sprytni będą mieli pomoc przy jeździe, gdy zajrzą w loga :D

[Benek]

Tak Maciek, to też jest sposób.

Co do mojej idei to wygląda na to, że jest ok. Log pokazuje to co powinien. Zdarzenia się wykonują. Wcześniej pokręciłem z opóźnianiem czasowym. Trzeba się trzymać tego co napisał Ziomal:

To zadziała tylko wtedy, gdy pozostałe eventy (krosowo2,3) mają zwłokę czasową (z tym, że zwłoka każdego kolejnego eventu musi być wyższa od poprzedniego).