Let’s Make a Game!

Step 10: “Random Numbers”

By Darrell Spice, Jr. (adapted by Duane Alan Hahn)

Support this site with PayPal.

Original Blog Entry

And yes, those are air quotes. Wink


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.

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

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 obtainedthat'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 ofif 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.

    ; 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 controlnamely the time it takes the human to things: hit the RESET switch to start a game, collect the next box, etc. I've added this to 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.

        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

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.

    ; 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
        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  

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.

        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.

        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

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:

Digits Graphics

The first change is the left 0 image was blanked outthis provides leading zero suppression:


The second change is the A image is now blanked outNewGame uses this to blank out the right player's score in 1 player games.

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

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


The ROM and the source are at the bottom of my blog entry.






< Previous Step



Next Step >






Table of Contents for Let’s Make a Game!


Goals for this tutorial.

Step 1: Generate a Stable Display

On other systems, the video chip generates the display; on the 2600, your program generates the display.

Step 2: Timers

Improve the display generation by using the built-in timer.

Step 3: Score and Timer Display

Using the playfield to display information.

Step 4: 2 Line Kernel

Draw the player objects (sprites) on screen (X & Y location).

Step 5: Automate Vertical Delay

Finish the Y positioning of the player objects (sprites).

Step 6: Spec Change

Revise our goals.

Step 7: Draw the Playfield

Display an arena (like the mazes in Combat).

Step 8: Select and Reset Support

Using the Game Select and Game Reset console switches.

Step 9: Game Variations

How to implement game variations (number of players, different mazes).

Step 10: "Random Numbers"

How to randomize your game.

Step 11: Add the Ball Object

Draw the ball on screen (X & Y location).

Step 12: Add the Missile Objects

Draw the missiles on screen (X & Y location)

Step 13: Add Sound Effects

Let’s make some noise!

Step 14: Add Animation

Make the humans run instead of glide.





Useful Links

Easy 6502 by Nick Morgan

How to get started writing 6502 assembly language. Includes a JavaScript 6502 assembler and simulator.



Atari Roots by Mark Andrews (Online Book)

This book was written in English, not computerese. It's written for Atari users, not for professional programmers (though they might find it useful).



Machine Language For Beginners by Richard Mansfield (Online Book)

This book only assumes a working knowledge of BASIC. It was designed to speak directly to the amateur programmer, the part-time computerist. It should help you make the transition from BASIC to machine language with relative ease.



The Second Book Of Machine Language by Richard Mansfield (Online Book)

This book shows how to put together a large machine language program. All of the fundamentals were covered in Machine Language for Beginners. What remains is to put the rules to use by constructing a working program, to take the theory into the field and show how machine language is done.



6502 Instruction Set with Examples

A useful page from Assembly Language Programming for the Atari Computers.

Continually strives to remain the largest and most complete source for 6502-related information in the world.



Guide to 6502 Assembly Language Programming by Andrew Jacobs

Below are direct links to the most important pages.



Stella Programmer's Guide

HTMLified version.



Nick Bensema's Guide to Cycle Counting on the Atari 2600

Cycle counting is an important aspect of Atari 2600 programming. It makes possible the positioning of sprites, the drawing of six-digit scores, non-mirrored playfield graphics and many other cool TIA tricks that keep every game from looking like Combat.



How to Draw A Playfield by Nick Bensema

Atari 2600 programming is different from any other kind of programming in many ways. Just one of these ways is the flow of the program.



Cart Sizes and Bankswitching Methods by Kevin Horton

The "bankswitching bible." Also check out the Atari 2600 Fun Facts and Information Guide and this post about bankswitching by SeaGtGruff at AtariAge.



Atari 2600 Specifications

Atari 2600 programming specs (HTML version).



Atari 2600 Programming Page (AtariAge)

Links to useful information, tools, source code, and documentation.




Atari 2600 programming site based on Garon's "The Dig," which is now dead.



TIA Color Charts and Tools

Includes interactive color charts, an NTSC/PAL color conversion tool, and Atari 2600 color compatibility tools that can help you quickly find colors that go great together.



The Atari 2600 Music and Sound Page

Adapted information and charts related to Atari 2600 music and sound.



Game Standards and Procedures

A guide and a check list for finished carts.




A multi-platform Atari 2600 VCS emulator. It has a built-in debugger to help you with your works in progress or you can use it to study classic games.




A very good emulator that can also be embedded on your own web site so people can play the games you make online. It's much better than JStella.



batari Basic Commands

If assembly language seems a little too hard, don't worry. You can always try to make Atari 2600 games the faster, easier way with batari Basic.



Back to Top



View this page and any external web sites at your own risk. I am not responsible for any possible spiritual, emotional, physical, financial or any other damage to you, your friends, family, ancestors, or descendants in the past, present, or future, living or dead, in this dimension or any other.


Home Inventions Quotations Game Design Atari Memories Personal Pages About Site Map Contact Privacy Policy Tip Jar