Page 2 of 2

Posted: Fri Aug 06, 2010 6:26 pm
by tepples
Kasumi wrote:Seven pieces. He used 3 bits. Seven of the possibilities deal the piece it corresponds to. (1= I, 2 = O, etc.) When the eighth possibility comes up he increments (or decrements) and wraps around a variable and deals the piece that corresponds to the current value of the variable.
I used this method, which I called "possession arrow", to simulate a uniform randomizer in versions of LJ65 (then called tetramino) prior to 0.33. In that version, I switched to the LRU system to reduce repetition, following Arika's TGM games that use a conceptually similar system.

Posted: Sat Aug 07, 2010 12:51 am
by neilbaldwin
@Tetris randomiser : just ace! I wish I could think like that :D

Posted: Sat Aug 07, 2010 2:25 am
by bogax
This question comes up a lot, so I've thought about it some.
I'm not sure I'm analyzing it correctly (and I haven't actually
tested it so take this with agrain of salt ;) )

My thought is to take a random number MOD your range and then
accumulate and hope that the bias accumulates and distributes
itself over the range. (or the bias ends up "diluted" in the
accumulation, depending on how you look at it)

Choose a range of random numbers that's easy to MOD to your target

So eg if you random number generator returns numbers 0-FF,
and you want random numbers in the range 0-1B mask off the lower
five bits (the next higher power of two, and if you start with
a range that's a power of two and MOD for a range thats a power
of two that shouldn't introduce any bias)

MOD that to your target range

Add it to your random number accumulator

MOD that to your target range.

something like this:

Code: Select all

 ; return a number in the range 0-1B 
 ; start with a random number 0-FF in a
 ; myrand needs to be intialized to be in range

 ; MOD to an easier power of two
 and #$1F           ; the assumption is if a is random in a range
                    ; that's a power of two this result should be random

 ; MOD that to the target range
 cmp #$1C
 sbc #$1B           ; biased to account for carry clear 

 adc myrand

 ; MOD to the target range
 cmp #$1C
 sbc #$1B           ; biased to account for carry clear 

 sta myrand

I forgot to mention you could use the next lesser power of two
to start and save some MODing.

My gut says that the larger the range you start with the better
off you'll be distribution wise.
So it becomes something of a trade off between the size of the range
and the effort spent doing the MOD.

I'd guess that using the next lesser power of two probably
wouldn't make a lot of difference especially if it's close to
your target range.

Posted: Sat Aug 07, 2010 4:46 am
by blargg
Here's one I came up with for use to generate a random value between 0-79, with uniform distribution (for use in Litewall, which has a 10x8 grid it wants to generate random coordinates into):

Code: Select all

    jsr random_256 ; A = random 8-bit value
    sbc #80
    bcc @done
    sbc #80
    bcc @done
    sbc #80
    bcs @retry
    adc #80
It divides by 80 and takes the modulus. This takes care of the first 240 values, leaving 16 extra. In that case, it gets a new random value and tries again. The probability of retrying the first time is 16 in 256, or 1 in 16. The probability of it retrying two times in a row is 1 in 16*16 = 1 in 256, and so on. This means that on average, it takes only slightly longer than random_256, but worst-case, it could take forever, assuming random_256 has an infinite period. If random_256 is a simple 8-bit LFSR, this routine will always terminate, since random_256 would then generate each value every 256 calls.

Posted: Sat Aug 07, 2010 6:46 am
by tepples
Or in C:

Code: Select all

unsigned char rand80() {
  unsigned char raw;
  do {
    raw = random_256();
  } while (raw >= 240);
  return raw % 80;
blargg wrote:If random_256 is a simple 8-bit LFSR, this routine will always terminate
In a video game or a real-time demo, you want the RNG to terminate within a guaranteed amount of cycles so that you don't overflow frame time. In this case, I'd recommend something similar to possession arrow logic for cases where the base RNG returns 240-255: increment a counter by 16 (mod 80) and then combine that with the low bits of the remainder. Or 3 bits for Y and 3 bits plus an LRU unit for X.

Re: Random Number Generation?

Posted: Tue Mar 05, 2013 4:08 pm
by Dafydd
Sorry for the necro post, but I didn't see another thread on the topic.

I want to produce a large number of random sequences of the numbers 0-15 where each number must occur exactly once. A 4-bit LSFR would make the sequence predictable very quickly, and an 8-bit LSFR (which would be much less predictable) doesn't guarantee that any 4 bits I choose (the last 4 out of 8, for example) do not have the same combination of values in a 16 values long sequence, as far as I know.

One solution could be to run fisher-yates on an array of the numbers I want, where the random number (i.e. the index) is taken from the last 4 bits of an 8-bit LSFR (picking the next value or truncating it should it be out of range) that is periodically seeded by the unknowing player by counting the number of frames passed between certain actions (in this case, pulling the trigger on the Zapper). That should give pretty good randomness, but I could be wrong, and I don't even know whether there's a way I could prove myself right or wrong.

Another solution could be to keep a table of sequences that are chosen from by the aforementioned frame counter, but that seems like a pretty bad idea considering, uh, [grabs a calculator] there are nearly 21 trillion different possible sequences and each sequence would need 8 bytes of memory for storage. So yeah, very bad idea.

So... does anyone feel right away that the 8-bit LSFR + Fisher-Yates solution is also a bad idea, for any reason? In particular, is anyone good enough at math to tell me whether or the sequences that are produced by this method are equally likely to happen, or whether there's a tendency to prefer a particular set of sequences? The delay between trigger pulls is likely to have some kind of normal distribution around 60 frames or so, but other than that... not sure whether I should investigate further or just try it and see how well it works. It's going to be in silico either way.

Re: Random Number Generation?

Posted: Tue Mar 05, 2013 4:42 pm
by tepples
What I'd use is a 16-bit LFSR (use Greg Cook's CRC16 from feeding Fisher-Yates.

Re: Random Number Generation?

Posted: Tue Mar 05, 2013 5:01 pm
by blargg
Is there any reason you can't do a straightforward shuffle of 16 values in RAM? Write an array with 0-15, then step through each of the 16 entries and swap it with a random entry from the array.

Re: Random Number Generation?

Posted: Tue Mar 05, 2013 5:18 pm
by Dafydd
How is a "straightforward" shuffle different from Fisher-Yates? It swaps with any value, not just the remaining ones? How does that ensure I don't get more than one of the same value in the sequence?

EDIT: Oh, wait. I'm stupid. Sorry.

Re: Random Number Generation?

Posted: Tue Mar 05, 2013 5:31 pm
by Dafydd
Now I'm really confused. When swapping a with a[j] in an array of length N, what is the purpose of having 0 <= j <= i (as in Fisher-Yates) when it might as well be 0 <= j <= N-1 (as blargg suggests)? It should have something to do with breaking the (un-)bias, but I don't know for sure.

Re: Random Number Generation?

Posted: Tue Mar 05, 2013 6:11 pm
by tepples
In theory, there's a bias in the case of 0 <= j < N. Proof: There are N! distinct permutations after the algorithm. With 0 <= j <= i, there are also N! distinct paths to these permutations. But with 0 <= j < N, there are N^N equally distributed paths. Because N! does not generally divide N^N (example: N = 3; 3! = 6 does not divide 3^3 = 27), these states don't all have the same number of paths to them; therefore bias.

But in practice, I dare someone else to prove that this bias is any more noticeable than the limitation that a CRC16 can generate only 65536 of the 2.1×10¹³ distinct permutations.

Re: Random Number Generation?

Posted: Tue Mar 05, 2013 6:21 pm
by Dafydd
I drew a trinary tree of possibilities for the array of [1, 2, 3] (i.e. length 3) and came up with 27 leaves, distributed like so:

123 x 4
132 x 5
213 x 5
231 x 5
312 x 4
321 x 4

I came up with a more elegant explanation, but tepples beat me to it.

Anyway, in this particular case, as tepples suggests, I think I'll run with blargg's version, because it's much easier to implement, and because the bias isn't going to matter, especially since the input will be shuffled from last time anyway.

Thanks, guys!

Re: Random Number Generation?

Posted: Sat Mar 09, 2013 1:03 am
by zzo38
I used ARCFOUR, running several times per frame when nothing else is doing, and including the microphone if it is available.

Re: Random Number Generation?

Posted: Tue Mar 12, 2013 5:36 am
by TmEE
This is not exactly NES stuff but in my MD game "Glass Breaker" I used this to create some garbage for random enemy business :

Code: Select all

ROR.W  #3, D0
EOR.W  D1, D2
ADD.W  D1, D0
ROL.W  #7, D1
ADD.W  D1, D0
EOR.W  D2, D0
It takes quite little time and provided me adequate enough output for the things I needed.
I did not really spend much time on, just arranged some instructions until I got satisfying result...