Obecnie mam do czynienia z systemem walki wieloosobowej, w którym obrażenia zadawane przez graczy są zawsze mnożone przez losowy współczynnik od 0,8 do 1,2.

Teoretycznie prawdziwie losowy RNG może ostatecznie uzyskać tę samą liczbę wiele razy (patrz dylemat Tetris ). Może to doprowadzić do meczu, w którym gracz zawsze zadaje bardzo duże obrażenia, podczas gdy drugi zawsze zadaje bardzo niskie obrażenia.

Co mogę zrobić, aby upewnić się, że tak się nie stanie? Czy niektóre RNG są lepsze od innych w unikaniu powtórzeń?

Możesz rozwiązać to w ten sam sposób, w jaki robi to Tetris, tworząc wstępnie ustaloną listę wyników obrażeń i przetasowania.

Powiedzmy, że wiesz, że gracz zada liniowe obrażenia o wartości od 0,8x do 1,2x. Weź listę [0,8, 0,9, 1,0, 1,1, 1,2]. Potasuj losowo , aby uzyskać np. [1.2, 1.0, 0.8, 0.9, 1.1].

Za pierwszym razem, gdy gracz zadaje obrażenia, zadaje 1,2x. Następnie 1x. Następnie itd. Do 1,1x. Tylko gdy tablica jest pusta, należy wygenerować i przetasować nową tablicę.

W praktyce prawdopodobnie zechcesz to zrobić jednocześnie dla ponad 4 tablic (np. Zacznij od [0,8,0.8,0.8,0.8,0.9,0.9,0.9,0.9, ...]). W przeciwnym razie okres sekwencji jest wystarczająco krótki, aby gracze mogli dowiedzieć się, czy ich kolejne trafienie jest „dobre”, czy nie. (Chociaż może to również dodać więcej strategii do walki, jak w tabeli Hoimi Dragon Quest IX , w której ludzie wymyślili, jak sondować, patrząc na leczące liczby i modyfikować, dopóki nie zagwarantujesz rzadkiego spadku.)

Napisałem do tego kod . Istotą tego jest używanie statystyk do korygowania pechowych serii. Możesz to zrobić, aby śledzić, ile razy zdarzenie miało miejsce, i użyć go do odchylenia liczby wygenerowanej przez PRNG.

Po pierwsze, w jaki sposób śledzimy procent zdarzeń? Naiwnym sposobem na to byłoby zachowanie wszystkich liczb kiedykolwiek wygenerowanych w pamięci i uśrednienie ich: co by działało, ale jest okropnie nieefektywne. Po krótkiej refleksji wpadłem na następujące (które są w zasadzie skumulowaną średnią ruchomą ).

Weź następujące próbki PRNG (gdzie wykonujemy, jeśli próbka jest> = 0,5):

Values: 0.1, 0.5, 0.9, 0.4, 0.8
Events: 0  , 1  , 1  , 0  , 1
Percentage: 60%

Zauważ, że każda wartość przyczynia się do 1/5 wyniku końcowego. Spójrzmy na to z innej strony:

Values: 0.1, 0.5
Events: 0  , 1

Zauważ, że 0przyczynia się do 50% wartości i 1przyczynia się do 50% wartości. Posunięto się nieco dalej:

Values: [0.1, 0.5], 0.9
Events: [0  , 1  ], 1

Teraz pierwsze wartości stanowią 66% wartości, a ostatnie 33%. Możemy zasadniczo sprowadzić to do następującego procesu:

result = // 0 or 1 depending on the result of the event that was just generated
new_samples = samples + 1

average = (average * samples / new_samples) + (result * 1 / new_samples)
// Essentially:
average = (average * samples / new_samples) + (result / new_samples)

// You might want to limit this to, say, 100.
// Leaving it to carry on increasing can lead to unfairness
// if the game draws on forever.
samples = new_samples

Teraz musimy przesunąć wynik wartości próbkowanej z PRNG, ponieważ wybieramy procentową szansę, tutaj rzeczy są znacznie łatwiejsze (w porównaniu z, powiedzmy, losowymi wielkościami obrażeń w RTS). Trudno to wytłumaczyć, ponieważ „przyszło mi to do głowy”. Jeśli średnia jest niższa, oznacza to, że musimy zwiększyć szansę wystąpienia zdarzenia i odwrotnie. Oto kilka przykładów

average = 0.1
desired = 0.5
corrected_chance = 83%

average = 0.2
desired = 0.5
corrected_chance = 71%

average = 0.5
desired = 0.5
corrected_change = 50%

Teraz „przyszło mi do głowy”, że w pierwszym przykładzie 83% było po prostu „0,5 z 0,6” (innymi słowy „0,5 z 0,5 plus 0,1”). W przypadku zdarzeń losowych oznacza to:

procced = (sample * 0.6) > 0.1
// or
procced = (sample * 0.6) <= 0.5

Aby wygenerować zdarzenie, należy zasadniczo użyć następującego kodu:

total = average + desired
sample = rng_sample() * total // where the RNG provides a value between 0 and 1
procced = sample <= desired

I dlatego dostajesz kod, który wpisałem w sedno. Jestem prawie pewien, że wszystko to można wykorzystać w scenariuszu przypadkowego uszkodzenia, ale nie poświęciłem czasu, aby to rozgryźć.

Oświadczenie: To są wszystkie statystyki domowe, nie mam wykształcenia w tej dziedzinie. Moje testy jednostkowe jednak zdają.

To, o co prosisz, jest w rzeczywistości przeciwieństwem większości PRNG, rozkład nieliniowy. Po prostu zastosuj w swoich regułach pewną malejącą logikę zwrotów, Zakładając, że wszystko powyżej 1,0x jest pewnego rodzaju „trafieniem krytycznym”, po prostu powiedz, że w każdej rundzie Twoje szanse na uzyskanie krytyka wzrosną o X, dopóki nie zdobędziesz które punkty resetują do Y. Następnie wykonujesz dwa rzuty w każdej rundzie, jeden dla określenia krytycznego lub nie, a drugi dla rzeczywistej wielkości.

Sid Meier wygłosił doskonałe przemówienie na GDC 2010 na ten temat i na temat gier cywilizacyjnych. Spróbuję znaleźć i wkleić link później. W gruncie rzeczy postrzegana losowość to nie to samo, co prawdziwa losowość. Aby wszystko było w porządku, musisz przeanalizować poprzednie wyniki i zwrócić uwagę na psychologię graczy.

Za wszelką cenę unikaj serii pecha (jeśli poprzednie dwie tury były pechowe, następna powinna mieć szczęście). Gracz powinien zawsze mieć więcej szczęścia niż przeciwnik AI.

Użyj zmiennego nastawienia

$0$$1$$r$$b$$0$

Ogólny rozkład będzie tendencyjny według następującego wzoru:

$r^{\exp (-b)}$

$b$$1$$b$$0$

Weź tę liczbę i skaluj ją odpowiednio do żądanego zakresu.

Za każdym razem, gdy gracz rzuci się pozytywnie, odejmij od błędu. Za każdym razem, gdy gracz rzuci się niekorzystnie, dodaj odchylenie. Zmienioną kwotę można przeskalować według tego, jak (nie) korzystny jest rzut lub może to być kwota płaska (lub kombinacja). Będziesz musiał dostosować określone wartości, aby dopasować je do swoich oczekiwań.