Inside the Atari (and computers in general), there's no such thing as a Random Number. We can, however, simulate random numbers by using a Linear Feedback Shift Register. The LFSR we're going to use was posted by batari, it's a rather slick bit of code in that it can be either an 8-bit or 16-bit LFSR.

Random: lda Rand8 lsr ifconst Rand16 rol Rand16 ; this command is only used if Rand16 has been defined endif bcc noeor eor #$B4 noeor sta Rand8 ifconst Rand16 eor Rand16 ; this command is only used if Rand16 has been defined endif rts

LFSR's create what appear to be a random sequence of numbers, but they're not. A properly constructed 8-bit LFSR will start repeating values after 255 values have been obtained. All you need to do in order to use the above routine as an 8-bit LFSR is allocate a variable called

**Rand8**:

; used by Random for an 8 bit random number Rand8: ds 1 ; stored in $AB

A 16-bit LFSR will repeat after 65535 values have been obtained - that's a lot better than 255; however, it requires you to allocate another variable. With the Atari's limited 128 bytes of RAM, games often didn't have RAM to spare so they'd just use an 8-bit LFSR. Collect is a rather simple game though, so we have RAM to spare and will allocate the second variable

**Rand16**.

; optionally define space for Rand16 for 16 bit random number Rand16: ds 1 ; stored in $AC

The random number generator does have potential problem to be aware of - if you're using an 8-bit LFSR and

**Rand8**has the value of 0 then the LFSR will always return 0. Likewise for the 16-bit LFSR if both

**Rand8**and

**Rand16**are 0 it will always return 0. So we need to initialize the LFSR as CLEAN_START set all the RAM variables to 0.

InitSystem: CLEAN_START ... ; seed the random number generator lda INTIM ; unknown value sta Rand8 ; use as seed eor #$FF ; both seed values cannot be 0, so flip the bits sta Rand16 ; just in case INTIM was 0

One thing that helps when using an LFSR is to keep reading values at a regular rate, even if you don't need the value. What this does is impose an element outside of the Atari's control - namely the time it takes the human to do things: hit the RESET switch to start a game, collect the next box, etc. I've added this to

**VerticalBlank**

VerticalBlank: jsr Random ...

Now that we have a function for random numbers we need to use them. First up is new routine that will randomly position any object. To use this function we just need to call it with X register holding a value that denotes which object to position. The values are the same ones used for the

**PosObject**function, namely 0=player0, 1=player1, 2=missile0, 3=missile1 and 4=ball.

RandomLocation: jsr Random ; get a random value between 0-255 and #127 ; limit range to 0-127 sta Temp ; save it jsr Random ; get a random value between 0-255 and #15 ; limit range to 0-15 clc ; must clear carry for add adc Temp ; add in random # from 0-127 for range of 0-142 adc #5 ; add 5 for range of 5-147 sta ObjectX,x ; save the random X position jsr Random ; get a random value between 0-255 and #127 ; limit range to 0-127 sta Temp ; save it jsr Random ; get a random value between 0-255 and #15 ; limit range to 0-15 clc ; must clear carry for add adc Temp ; add in random # from 0-127 for range of 0-142 adc #26 ; add 26 for range of 26-168 sta ObjectY,x ; save the random Y position rts

I've renamed

**InitPos**to

**NewGame**and modified it to call

**RandomLocation**. It runs through a loop setting all the box objects. Starting X value will be 1 or 2 based on the number of players in the selected game variation.

NewGame: ... ; Randomly position the boxes for the new game. Set X to 1 for a 1 player ; game or 2 for a 2 player game so that the appropriate objects will be ; randomly placed in the Arena. lda Variation and #1 ; value of 0=1 player game, 1=2 player game tax ; transfer to X inx ; start with 1 for a 1 player game, or 2 for a 2 player game IPloop: jsr RandomLocation ; randomly position object specified by X inx ; increase X for next object cpx #5 ; check if we hit 5 bne IPloop ; branch back if we haven't ... rts

I also modified

**OverScan**so that during a 1-player variation a collision between player0 and player1 will be detected. If so, it calls another new function,

**CollectBox**.

OverScan: ... bit Players ; test how many players are in this game variation bmi RightPlayer ; test Right Player collisions if its a 2 player game bit CXPPMM ; else see if left player collected box drawn by player1 bpl OSwait ; player0 did not collide wth player1 ldx #1 ; which box was collected jsr CollectBox ; update score and reposition box jmp OSwait ; 1 player game, so skip Right Player test ...

**CollectBox**will increase the player's score and call

**RandomLocation**again to move it to a new position. When

**CollectBox**is called, Y must hold which player (0 for left, 1 for right) and X must hold the object that was collected.

CollectBox: SED ; SEt Decimal flag clc ; CLear Carry bit lda #1 ; 1 point per box adc Score,y ; add to player's current score sta Score,y ; and save it CLD ; CLear Decimal flag jsr RandomLocation ; move box to new location rts

**CollectBox**means that the game is now playable for 1-player games! I managed to score 26 on game variation 1, how well can you do?

One thing you might notice in that screenshot is that the right player's score is not visible. Since we're done using the score for diagnostics, I've made a few changes to the digit graphics:

The first change is the left 0 image was blanked out - this provides leading zero suppression

The second change is the A image is now blanked out -

**NewGame**uses this to blank out the right player's score in 1 player games.

NewGame: ... ; reset scores ldx #0 stx Score bit Players ; check # of players bpl BlankRightScore stx Score+1 rts BlankRightScore: lda #$AA ; AA defines a "space" character sta Score+1 rts

Lastly the graphics for B thru F have been removed to save ROM space.

ROM

collect_20140710.bin

**(2KB)**

downloads: 140

Source

Collect_20140710.zip

**(49.74KB)**

downloads: 143

- Thomas Jentzsch likes this

I did some tests using ENT, which showed a significant improvement in serial correlation if you rotate Rand8 and Rand16 in opposite directions (like you do). Which is no surprise because the return value XORs both values

(though, the higher the value for the XOR value, the less relevant this becomes; especially $eb and $fc are even

slightlybetter without reversing the direction; Iguessthe number of high bits set plays a role here).I also tested all possible values for XOR ($9c, $b4, $bd, $ca, $eb, $fc) and especially $9c gave good results for all tests (especially chi square).