# Let’s write Lights Out in BASIC – part 4

See also: part 1, part 2, part 3, part 4, part 5, part 6 and part 7.

Where where we?

Oh, right. Light Out, in very basic BASIC.

If Lights Out always started with the same lights on, once you figured out how to win, you could repeat those steps and win every time. This reminds me of a wooden golf tee game I was given as a child. (If you have ever eaten at a Cracker Barrel restaurant, you probably have seen this — they have/had one on every table.)

I never learned how to win that game intentionally, but sometimes I would get lucky. This made visits to Cracker Barrel sometimes frustrating. The game had a listing of rankings based on how many pegs you had left at the end of the game. I was often an “EG-NO-RA-MOOSE.” :)

But then the iPhone happened in 2007, and a year later there was an App Store and you could play games on the phone! I found a peg game app and decided to learn and memorize the steps that win the game. I took screen shots of every step so I could consult them later. Here is one of those tiny 320×480 screen shots taken in 2008 on my original 2007 iPhone:

While I no longer remember those steps, I did for awhile, and visits to the Cracker Barrel were never the same. I was the peg game master! But soon it become boring and not worth playing since I knew how to win it every time.

Oh well. At least the collard greens and fried okra were still great.

Side Note: During research for this article, I found that Cracker Barrel has a blog post with the history of the peg game, as well as all the steps to solve it.

But I digress…

## “Random” game variations

The current program has an initializing routine which turns random lights on. But does it really?

As I wrote in an earlier article about RND, RND is not really random. On my CoCo, each time I turn it on, I can print some random numbers. Each time I power cycle and try it again, I will get those same “random” numbers. Here is an example of the first eight random numbers between 1 and 50 on the CoCo:

Any programmer that writes something that relies on RND to generate levels or patterns should be aware that it will make the same level or pattern each time the program runs from a fresh power up. BUT, in Color BASIC, you can seed the random number generator to change that pattern. It works by passing in a negative value to RND. When you do that, it seeds the number generator to a specific and repeatable sequence for that seed value.

If you run this code on a CoCo, you will see it print the same set of eight random numbers ten times:

`10 FOR A=1 TO 1020 B=RND(-42)30 FOR B=1 TO 840 PRINT RND(50);:50 NEXT60 PRINT70 NEXT`

This means that if I powered up my computer and ran this Lights Out program, I would get the same pattern the next time I powered up and ran the program.

This is probably not a problem that really needs to be solved, but since there is a simple solution, it makes for a good excuse to discuss it.

## Seeding the random number generator

In Extended Color BASIC, there is a TIMER function that starts at 0 on power up, then increments every 60th of a second until it rolls over and starts again from 0. Since the amount of time between power up, typing in “CLOAD” or whatever, and “RUN” will vary, using that value makes for a simple seed:

`A=RND(-TIMER)`

Just doing something like that at the start of the program should be enough to reduce chances that the patterns are not the same each time the game is played from a fresh start.

BUT, Color BASIC does not have TIMER. It would need a different approach to creating that number. If the program has a title/splash screen, it might sit in a loop waiting for the user to press a key to start. Something like that could be used to create a seed number:

`PRINT "PRESS ANY KEY TO BEGIN:"xx S=S+1:IF INKEY\$="" THEN xxA=RND(-S)`

It is not perfect since if the user types RUN and quickly hits a key, there is a good potential that the program would be using one of only a few seeds based on the low numbers that the counter got to. But, hey, better than nothing… And that’s something.

We could also keep incrementing that S variable inside the main program loop. If the user chose to play again (our program does not offer that feature, yet), the value could be used to create more random patterns. This is probably overkill, but it would be simple to add.

## Predictable randomness could be a feature…

I recall some game that came with Microsoft Windows (maybe a Solitaire, or perhaps Minesweeper) that had a spot where you entered a “game number” or something. This let you replay a specific game. I did not realize it at the time, but this was probably just seeding a random number generator so the order of the cards or the mines (whatever game it was) would be the same for those that wanted to try again.

Update: I was close! It was apparently FreeCell for Windows 95. I asked BING’s AI and it told me:

I believe the game you are referring to is FreeCell. FreeCell is a solitaire card game that was first introduced in Windows 95. It is a popular game that allows players to replay specific games by entering a “game number” 1If you’re interested in playing FreeCell, you can download it from the Microsoft Store 1.

I hope this helps!

– BING AI

Thank you, large language model.

But I digress…

The game could try to randomize, but could also allow the user to pick a “game number” that would be repeatable. That could be a fun feature, since players could use it to practice different strategies.

It could be as simple as something like this (for Extended Color BASIC which has the TIMER function):

`xx INPUT "PLAY GAME (1-65535, 0=RND)";SIF S<0 OR S>65535 THEN xxIF S=0 THEN S=TIMERA=RND(-S)`

Or if TIMER was not available, it could prompt the user then sit in a loop counting and use the count value as the seed. This is not a great approach, but might work…

`PRINT "PLAY SPECIFIC GAME # (Y/N)?"xx S=S+1:A\$=INKEY\$:IF A\$="" THEN xxIF A\$="Y" THEN yyIF A\$="N" THEN A=RND(-S):GOTO zzGOTO xxyy INPUT "PLAY GAME (1-65535)";SIF S<1 OR S>65535 THEN yyA=RND(-S)zz RETURN`

I decided to add it to the program as a subroutine that can be called before the main game loop:

`6000 REM SELECT GAME6010 PRINT "PLAY SPECIFIC GAME # (Y/N)?"6020 S=S+1:A\$=INKEY\$:IF A\$="" THEN 60206030 IF A\$="Y" THEN 60606040 IF A\$="N" THEN A=RND(-S):GOTO 60906050 GOTO 60206060 INPUT "PLAY GAME (1-65535)";S6070 IF S<1 OR S>65535 THEN 60606080 A=RND(-S)6090 RETURN`

I could just call this before the game begins:

`5 REM SELECT GAME6 GOSUB 600010 REM INITIALIZE GRID20 GOSUB 400030 REM SHOW GRID40 GOSUB 100047 IF LO=0 THEN PRINT "YOU WON!":END48 PRINT "LIGHTS ON:";LO50 REM INPUT SQUARE60 GOSUB 200070 REM TOGGLE SQUARES80 GOSUB 300090 REM REPEAT100 GOTO 30`

This would be simple enough to allow the user to replay a specific game. Here is a screen shot showing two instances of the XRoar emulator running the program, and generating the same pattern by using the same random seed:

This still is not 100% what we might want. While it does allow the user to request a specific game over and over, if they choose a random game, there is no way to get back to that game — it was chosen randomly.

To do that, we’d pick a random number for the “game number”, then use that as the seed value and display it as part of the game (so the user knows which number to use next time). We would still need to do some initial random seeding at the start so the game did not choose the same pattern of game numbers.

Here is a modification to the “select game” routine with some variable changes (GN for game number):

`6000 REM SELECT GAME6010 PRINT "PLAY SPECIFIC GAME # (Y/N)?"6020 S=S+1:A\$=INKEY\$:IF A\$="" THEN 60206030 IF A\$="Y" THEN 60606040 IF A\$="N" THEN A=RND(-S)6045 GN=RND(65535):A=RND(-GN)6046 GOTO 60906050 GOTO 60206060 INPUT "PLAY GAME (1-65535)";GN6070 IF GN<1 OR GN>65535 THEN 60606080 A=RND(-GN)6090 RETURN`

Then, we could print the game number before it prints the grid each time:

`1000 REM SHOW GRID1005 PRINT "GAME NUMBER:";GN1010 FOR Y=0 TO 41020 FOR X=0 TO 41030 IF L(X,Y) THEN PRINT "X";:GOTO 10501040 PRINT ".";1050 NEXT1060 PRINT1070 NEXT1080 PRINT1090 RETURN`

Now I can have the program generate a “random” game for me, and use that game number later to get the same puzzle.

At this point, we have a fairly playable (though ugly) version of a 5×5 Lights Out game.

There are a few more “nice to haves” we can add, so we’ll do those in the next installment.

Until then…

## One thought on “Let’s write Lights Out in BASIC – part 4”

1. Jason Pittman

I haven’t thought about this in years, but I think that back before TIMER, I would make something “seem random” by seeding RND with the value of the address that held the state of the color-changing cursor. It’s far from perfect for a lot of reasons, but it was a way to make it generally not be the exact same pattern every time without any user intervention. I think this is the address…

```10 PRINT RND(-PEEK(148)) ```

This site uses Akismet to reduce spam. Learn how your comment data is processed.