Monday, 13 February 2017

Basic 10-Liners Contest 2017

Gunnar Kanold and his friends run a really neat Basic programming contest. It has been going for a number of years. It started out, I believe, as an all Atari event but a few years back they decided to open it up to other classic 8-bit home computer systems. This year the contest is being held on Saturday April 22 at the NOMAM retro convention in Lubeck Germany. Details about the contest can be viewed here:

I decided to try programming the classic puzzle game "Minesweeper." I managed to get the game boiled down to 10 lines of Micro Color Basic on my favourite computer, the TRS-80 Micro Color Computer (MC-10). The original version of the program only did a 4-way search (up,down,left,right) for doing the flood fill after you select a location:

However, as with so many of my programming projects, a little more effort allowed me to condense the program just that wee bit more to allow me to fit in a full 8-way search:

Hard Version with 40 Mines
Here are some brief instructions for getting the game to run:
Run VMC10.exe
Type CLOAD & hit ENTER. From the File menu select “Play Cassette File…” and then select SWEEPER.​C10 in the JimG subdirectory of the Cassette directory. Type RUN...
(Any trouble running it, make sure under the “Configure” menu that Memory is set to +16K Ram Expansion).
I should note that these instructions will work for getting any of my games to run, since all of the rest of my programs are also included in the JimG subdirectory of the zip compilation. This compilation includes the wonderful VMC10 emulator by James the Animal Tamer. Thanks so much James!

In addition to the 10 line limit, this year the rules were changed to require that the same program be submitted in a "long version", which means, with one command per line. Line jumps (GOTO, GOSUB) and other dependencies have to be adjusted so that the program remains fully functional. I'm not sure what this is all about, but perhaps it is to help with the judging, or perhaps Gunnar might want to use the programs to help teach students about Basic programming. I seem to recall that he was involved with teaching. In any case here is the original 10-line version and the long version:
0 CLS0:DIMF(10,10),K(255),A(2000),B(8),J,B,L,X,Y:B(1)=-1:B(2)=1:B(3)=-32:C=RND(-(PEEK(9)*256+PEEK(10))):D=1:B(4)=31:GOTO9
1 A$(1)=CHR$(96):I=0:FORY=1TO9:FORX=1TO9:J=-(PEEK(32*Y+X+M)=46):PRINT@32*Y+X,A$(-(F(X,Y)=1));:I=I+J:NEXT:NEXT:RETURN
2 SOUND9,1:B(5)=-31:B(6)=-33:B(7)=32:B(8)=33:K(65)=-1:K(83)=1:K(87)=-32:K(90)=32:FORY=1TO9:FORX=1TO9:POKE32*Y+X+M,46:NEXT:NEXT
3 L=RND(9):B=RND(9):ON-(F(L,B)=1)GOTO3:F(L,B)=1:J=J+1:ON-(J<10)GOTO3
5 Y=INT((A(B)-M)/32):X=(((A(B)-M)/32)-Y)*32:IFF(X,Y)=1THEND=2:ON-(P=A(B))GOTO9:D=1:FORJ=1TO1:GOTO8
6 C=F(X-1,Y-1)+F(X,Y-1)+F(X+1,Y-1)+F(X-1,Y)+F(X+1,Y)+F(X-1,Y+1)+F(X,Y+1)+F(X+1,Y+1)+48:IFC<>48THENPOKEA(B),C:FORJ=1TO1:GOTO8
7 POKEA(B),32:FORJ=1TO8:IFPEEK(A(B)+B(J))=46THENL=L+1:A(L)=A(B)+B(J):POKEA(L),32
9 M=16384:P=33+M:ONDGOTO2:GOSUB1:?@416,"SAFE!":IFI<>10THEN?@416,"DEAD!":FORC=1TO10:SOUND1,1:POKE49151,64:POKEA(B),64:NEXT
20 REM     minesweeper
21 REM     ***********
23 REM
0 CLS0
1 DIMF(10,10),K(255),A(2000),B(8),J,B,L,X,Y
2 B(1)=-1
3 B(2)=1
4 B(3)=-32
5 C=RND(-(PEEK(9)*256+PEEK(10)))
6 D=1
7 B(4)=31
8 GOTO900
100 A$(1)=CHR$(96)
101 I=0
102 FORY=1TO9
103 FORX=1TO9
104 J=-(PEEK(32*Y+X+M)=46)
105 PRINT@32*Y+X,A$(-(F(X,Y)=1));
106 I=I+J
107 NEXT
108 NEXT
200 SOUND9,1
201 B(5)=-31
202 B(6)=-33
203 B(7)=32
204 B(8)=33
205 K(65)=-1
206 K(83)=1
207 K(87)=-32
208 K(90)=32
209 FORY=1TO9
210 FORX=1TO9
211 POKE32*Y+X+M,46
212 NEXT
213 NEXT
300 L=RND(9)
301 B=RND(9)
302 IFF(L,B)=1THEN300
303 F(L,B)=1
304 J=J+1
305 IFJ<10THEN300
400 POKEP,PEEK(P)+64
401 K=ASC(INKEY$+"@")
402 POKEP,PEEK(P)-64
403 IFK=0ORPEEK(P+K(K))=128THEN400
404 P=P+K(K)
405 L=1
406 B=1
407 A(B)=P
408 IFK>32THEN400
500 Y=INT((A(B)-M)/32)
501 X=(((A(B)-M)/32)-Y)*32
502 IFF(X,Y)=1THEND=2:ON-(P=A(B))GOTO900:D=1:FORJ=1TO1:GOTO800
600 C=F(X-1,Y-1)+F(X,Y-1)+F(X+1,Y-1)+F(X-1,Y)+F(X+1,Y)+F(X-1,Y+1)+F(X,Y+1)+F(X+1,Y+1)+48
700 POKEA(B),32
701 FORJ=1TO8
702 IFPEEK(A(B)+B(J))=46THENL=L+1:A(L)=A(B)+B(J):POKEA(L),32
800 NEXT
801 B=B+1
802 IFB<=LTHEN500
803 GOTO400
900 M=16384
901 P=33+M
902 ONDGOTO200
903 GOSUB1
904 PRINT@416,"SAFE!"
905 IFI<>10THENPRINT@416,"DEAD!":FORC=1TO10:SOUND1,1:POKE49151,64:POKEA(B),64:NEXT

In addition to the Sweeper game, last year I made a game based on a suggestion from someone from Brazil who commented on one of my programs a while back.  He told me about a game he had made when he was a kid. √Črico also sent me an image that had reworked using his old machine. He also described a little how it worked. Based on his recollections, I came up with another game, which I was able to cram into 10 lines in the hope of entering it into the NOMAM 2016 competition, but I was too late. So here is the "Monteiro Challenge," an arcade space flying game with 3 levels to get through, for this year's competition:

Anyway, I don't know if any of these game are any good as games, but they sure were a lot of fun to program. Thanks to Gunnar and the folks at the NOMAM retro event for organizing a great competition. Have fun in Lubeck this year!

I had been hoping to get a car game going for the contest, But I can't for the life of me think of how I can get a game dynamic that wont sap the speed of the basic algorithm that I came up with for drawing a moving road graphic. I'll keep plunking away at it. It's called Formula1:

In addition to this program I have been busy lately making some ports of old code from other systems and reprogramming efforts based on videos I have seen. For example, RRUNNER.C10 is a game based on a Sinclair ZX-81 game, which can be seen on Villordsutch's page:

Here is a modification of some code by my friend Robert Sieg from the MC-10 Yahoo group that draws a friendly frog. I was always intrigued by the starring white eyes of the frog and decided to animate them to make a version of what I call MC-10 Hynotoad:

Quite a bit of programming work had to go into converting a game from QBasic that recreated the Mattel Football classic handheld game from the 1970s. The Qbasic code was by bomberpunk. See this thread for info and a vid of the original:

In addition to the above I have also completed the following projects since I last posted:

Island of Secrets
Island of Secrets is a type-in listing in the book of the same name, which is a free PDF available for download from Usborne Publishing: As well as the listing the book contains an illustrated background story to the adventure. Some of the illustrations contain information that may aide the adventurer. I ported it from Commodore 64 version I found on-line. However, there were some bugs in it which prevented it from being winnable (or even playable). I fixed'em. Here's a video of a 64 version. Don't know if its the same one:

Re-programming of Plunkit for the TRS-80 Coco by Roger Taylor. My MC-10 version was based on the Highretrogamelord video:

Aardvark Software text adventure, ported from Commodore VIC 20 to TRS-80 MC-10. For original see:

A closer examination of the source has prompted some alterations to how the maze is drawn. Now level choice influences the amount of free space present on screen.

VicTron Port of Tron by F. G. Huerta
Originally for the Commodore VIC 20. This is a port of the program to Micro Color Basic for the TRS-80 Micro Color Computer. For the original see:

Port to the TRS-80 MC-10 of a game for the Acorn Atom by Dino Dini called "CupBall." For the original see:

Awful Green Things for the TRS-80 MC-10
Ported an Acorn Atom version of this classic board game to MC-10. See here for more details about the original:  (GREENTHI.C10)

Robot Nim
Ported from Acorn Atom to the TRS-80 MC-10. Original Basic source by P. Mainwaring, Sept 1981

Sniper 1K Game
Ported from a Sinclair ZX-81 1K games compilation. See:
(SNIPER.C10 in the 4K directory of JimG)

Orbit 1K Game
Ported from a Sinclair ZX81 1K game compilation. See:
(ORBIT.C10 in the 4K directory of JimG)

Escape from Colditz
From the World of Stewart, a teenage software creation re-imagining escape from the famous WW2 POW camp. See:

Jet Pac for the TRS-80 MC-10 based on an ZX81 game you can see here:

Bowling Champ
Basic game ported to TRS-80 MC-10 from Apple 2 game found at:

Saturday, 26 November 2016

Takaya Arita's Classic "Cavern 2160"

I ran across an interesting looking game ported to the MZ-80 by Joachim Froholt. He mentioned in the blurb for his YouTube vid that:
I translated Takaya Arita's Sharp MZ-80K classic Cavern 2160 to the Sharp MZ-80A (& english).
When I hear someone describing a Basic game as a "classic" my ears immediately pluck up. What is this classic of which you speak? The original game was published as a program listing in the July 1980 issue of I/O Magazine in Japan. I asked Joachim if he had a copy of the original source. He kindly pointed me towards a place where I might find a scan of the article. In the end I decided to simply look up as many videos of the game being played as I could to recreate what I saw using my own code and coding tricks to get speedy animation out of the MC-10. I did eventually get a scan, which was helpful in resolving a few details of the operation of the game, although I am still not sure if I have fully implemented the game, or implemented it with complete fidelity. For example, in my version there is an ultimate time limit. You get quite a bit of time to build your score, but as you do the game gets slightly harder in regular jumps (signaled by some random beeping). At these points the time it takes for the snakes to come back to life after falling shortens. But also, you can reach a point when the time will simply run out. That being said. I have never been able to play to that time.

The original game is described as a classic because, to quote the retro gamer blog:
Dr Takaya Arita’s game is a milestone release from 1980 – it has been considered “the original sandbox game,” and is a strategic digging game that arrived a good couple of years before the likes of Dig Dug and Mr Do.  36 years on, Mindware is now releasing the game on PC, in three different forms. The original version for the Japanese Sharp MZ-80 computer will be converted, and two remixed versions will be provided – one built to the specs of the Sharp MZ-700, and another built as a classic Eighties arcade game. 
The game seems like it would be simple, but it takes a lot of strategy to remove earth in a way that prevents the snakes from overwhelming you or sneaking past and making their way to your "base" and thus, defeating you.  I was able to find various version and ports to other system, including one with a pixel text drawn version of the original Japanese name of the game, which I was able to recreate as a title screen for my version. Strangely enough when I sent Joachim a video of the game I had recreated he noticed my port of  "The Valley" and sent this message:
BTW, I see your last project was The Valley, that's a fun coincidence,
because I was involved with a version for the Sharp MZ-80A just
recently. I only did playtesting for that one. An interesting little
game, more fun than I originally thought it'd be. Here's a video: 
It's a small world when porting projects are being done in such similar succession. Perhaps it's a sign that the pool of "classics" is somewhat limited. Maybe I'm coming to end of it!  Let's hope not. Anyway here's the vid of my version:

Nuclear Submarine Adventure

Commodore 64 Version
TRS-80 MC-10 Version

Nuclear Submarine Adventure was a text adventure published in 1980 by Aardvark Software. Its author was Robert J. Retelle, who also wrote the Star Trek Adventure that I ported recently. Versions exist for the C64/128, OSI/Compukit, TRS-80, TRS-80 and CoCo.  It seemed time to make a version for the MC-10. The source code was provided to me after an inquiry to the Coco e-mail list, by Guillaume Major, who oversees the Coco Archive. I found out about the game because Colin Appleby of the Grundy Newbrain Emulator site, asked me on solution archive forum whether I had the source. That sent me to Curtis Boyle's Coco game website. An inquiry to Curtis via the e-mail list (maintained by Dennis of prompted him to respond that he couldn't place his finger on a copy of it, but the posting  prompted Guillaume  to hunt up a copy from some obscure disk and put it up on the archive.  That's a lot of work being done by a lot of different people sharing across the internet to facilitate the retrocomputing hobby!

Anyway, SPOILER ALERT!  Below I have included a walkthrough and a map thatI created as I game tested the ported source code. I had to simplify all the fancy music. This included a routine that ran a submarine "ping" noise while you are prompted to enter your command. No great loss... I found the ping a little annoying.

I think I found an error in the save routine. It didn't seem to preserve the variable that recorded that you had used the chair to smash open one of the hatches.  So every time you saved you had to get the chair again and re-smash the hatch.  I added that variable to the save routine.  I also added the synonym "GET" for the "TAKE" command, and the options to use U,D,F,A as shorthand for GO UP,GO DOWN,GO FORWARD and GO AFT.

   Room      Room       Room       Room                 Quarters   Room
    /                               /                     /
   /                               /                     /
Tool                           Battery               Flooded
Room                           Room                  Compartment

About the Story
You are trapped in a crippled nuclear missile submarine and must make your escape.

You made it! Don't get the bends on the way up!

Monday, 14 November 2016

The Valley: The Adventure Continues

Found out "The Valley" actually started out as a very popular type-in for the Commodore Pet, which was then ported to a variety of systems including the original TRS-80 Sharp MZ-80, BBC and Apple. Here are some links discussing it:

I think, from what I have read that this classic RPG was first published in Computing Today April 1982. I was able to get a listing and based on that and the viewing of many pictures of various versions, I realized that the Newbrain version had departed from the original in some ways. The most obvious was that instead of having two castles at each end of the central "path," the Castles were simply placed randomly.  Also, the map was redrawn every time you entered the valley scene from one of the other scenes (Swamp, Forest, Tower). By pouring over the original listing I was able to restore the game's function to be more like the original Pet version. I was also able to clean up the graphics quite a bit, such as making the castles look a little more like castles and the tower more like a tower. Adding better collision detection also prevents attribute clash between these elements. Now the save game feature actually saves the map info so the valley remains steady from saved game to saved game. Lots of other minor fixes too.  Here's how it looks now:
Now forests and swamps, like in the Pet version, are two characters wide. The tower is two characters high. Also revamped the beginning instruction screen to provide more detail about the keys used in the program and revamped and sped up the key input to allow for the option to use all eight directions, instead of just up down left and right, as I think it was in the Newbrain version (which made moving very tedious). Now you can use either: 
 A D
The original used the numeric keypad for movement.  Since mine uses the left letters of the keyboard you must press R instead of E to get a report of your rating level and what items you have recovered. I also changed the map routine for the Tower, Lair and Temple so that it used the original Pet routine:
Now the maps are much smaller (and less tedious to explore) and more interesting than the ones generated by the Newbrain code:
I also changed the lake and island drawing routine for the Swamp and Forest to use the Pet code. On the whole it has been a very satisfying project. I've learned about a classic RPG and done some intensive code fixing with the help of a very nice article published in Computing Today back in 1982...

Wednesday, 2 November 2016

October Retrochallenge 3: The Valley

Here's my final project of the October Retrochallenge. I finished just a little too late to make the 31st deadline, but in the spirit of better late than never, I'll post about a porting project I embarked on over the last week to help cheer myself during one of the most challenging times I have at work every year, midterms! Lot's of marking of exams and papers makes this a time, along with mid-winter, that I really need some pleasant distraction.
Grundy Newbrain 8-bit computer
I am a member of the CASA website "Solution Archive" dedicated to Interactive Fiction, including classic adventure games. Colin Appleby joined the group and asked a lot of questions in the "classic forum," about adventures with versions for the Grundy Newbrain 8-bit computer of the UK. He was looking for games for this quirky little 8-bit machine, which was a little like the MC-10, in that it never really gained a big enough market share to be considered one of the mainstream home computers. Like the MC-10, it was bit of an outlier, which is just one of the features that can make a machine so endearing as an object of retrocomputing interest.

One of the games Colin mentioned in his posting was a Basic RPG called "The Valley." This, of course. elicited some complaints from the IF purists in the group that it wasn't really an example of interactive fiction or text adventuring. I think such distinctions are rather arbitrary and was quite happy to hear that Colin had made the file available on the Newbrain emulator site. I am always on the lookout for basic source code!
Kayde Manual
The game is from the Kayde company and was originally distributed on tape. Colin's distro not only included a file for loading into the emulator but also the text source code. Oh how I wish everyone who distributed Basic games for emulators did this! It means you don't have to figure out a new system, its emulator and all the tricks about how to get a Basic file in text format out of the system. The source also lists Chris Despinidis as contributing some debugging. I think Chris is the maker of the Newbrain emulator. See: for more info about the Newbrain.

The Newbrain has a 40X24 screen and the game uses simple "text graphics." Since the MC-10 doesn't have 24 lines, it was useful to be able to use the 64X32 8 color low-res graphics to recreate the text maps. Instead of using various characters to represent the objects on the map (forests, lakes, castles, dark tower, woods, safe path, swamp) I was able to use colours. I also had space left over on the right hand side to put a colour key to explain what each colour represented, since 64-40=24 dots or 12 characters. Luckily there weren't too many items, so 8 colors and black were basically enough to represent everything needed for the maps, with only a little careful doubling up of some colours for slightly different uses on the 3 basic types: terrain, forest/swamp, and castle/tower. The result is a little speedier than the original (I was able to get the game up and running on the Newbrain emulator to help with the porting project), which I think is simply because the MC-10 was developed about 3 years later.  As usual, I never know if I have fully debugged, but I will continue to play the game for a while and hope to weed out any that may be left.

In fact, I think I might have spotted some bugs in the original source. I shared this info with Colin on the MC-10 Facebook page. I found an error in line 3820 of the original source that I had downloaded (back in September) that involved a missing colon before a PUT command (how the Newbrain outputs special characters to the screen). Having had my source for some time it's possible Colin or Chris has debugged it in the meantime. I also noticed that line 9000 should probably have had a GOSUB20000 in it instead of GOSUB2000, since the former was a commonly called subroutine, whereas the later was definitely not. However, this GOSUB would possibly never have been triggered in the original because it was in an IF statement looking for a character 230, which I could not find "PUTed" anywhere in the source. My best guess was that a code 254 was what was really needed and adjusted my MC-10 version accordingly to use the right POINT check (to sense the color of the screen locations and return a number from 0-8 for the color found). The command now randomly triggers a message that there is no entry to the buildings on the islands (in the middle of swamps and forests) from the direction one is coming and to seek another route in. So perhaps, the MC-10 version has a feature that even the Kayde original lacked?!

Thanks to John and the other participants in the Retrochallenge, and to Colin and Chris over on the Newbrain site for sharing their retrocomputing enthusiasm!

Friday, 21 October 2016

October Retrochallenge 2: Fur Trader and a Graphic Demo

I have a colleague at my university, who when I mentioned my interest in old Basic programs recalled playing a game called "Fur Trader." I told her that I had done a port of a classic simulation called "Oregon Trail" and I think she said that she had played that one too, but had really liked Fur Trader because of its connection to Canadian history.
Since I had so much fun porting and playing Oregon Trail, and I'm also a big Canadian history buff, I thought I would try to look for Fur Trader. I can almost always find a TRS-80 version of any classic Basic text oriented program so I went to one of the major archives for that system that I've stumbled across over the years and looked under the "F" filename section. Sure enough, there was Fur Trader. I then used a handy little utility called TRSTools by Mathew Reed to view the Basic source on any TRS-80 disk or cassette file (for a cassette files you must first drag and drop the file onto a virtual disk).  Here is a link to an Atari site with a page scan from the a David Ahl book of games that includes the game.

Then it was just a question of cleaning out the commands distinct to the elder TRS-80. Micro Color Basic doesn't have the DEFINT command, for example, to allow designating variables as integers. Everything must be floating point for the MC-10 so sometimes some strategic INT functions must be added to a program if there are operations that really need only an integer. In the case of Fur Trader, the program used a number of PRINT USING commands to format trading values and costs to two decimal places and with a leading dollar sign. Over the years I've built up a collection of special Basic routines to recreate the functionality of commands like this. I had one in my collection for printing values with just two decimals and no leading space (so the dollar sign can be right next to the first digit).  Here's what it looks like:
8 CC=VAL(M$):ZZ=LEN(STR$(INT(CC)))-1:I$=RIGHT$("        "+STR$(INT(CC)),ZZ):I$=I$+MID$(STR$((CC-INT(CC))+1.00001)+"000",3,3)
You assign the number to variable CC and then GOSUB 8. The subroutine returns string I$ formatted to two decimal places and no leading space. You can then print it directly or add it to another string for printing or further string formatting, such as my word wrap or reverse video printing routines, which generally take M$ as their input.

As with my conversion of Oregon Trail, I added some simple graphics to try to help spice up the program a little. In this case I used my SKETCH program to draw some simple fort diagrams. Here is Fort Hochelga (Montreal):
The original title screen describes the program as follows:
You are the leader of a French fur trading expedition in 1776 leaving the Ontario area to sell furs and get supplies for the next year. You have a choice of three forts at which you may trade. The cost of supplies and the amount you receive for your furs will depend upon the fort you choose. You also specify what types of furs that you want to trade.
It's a very simple simulation. Basically you choose the fort you want to choose to trade at from a selection of 3 possibilities and the numbers of different types of pelts. The game randomly selects some hazards and trading prices depending on the fort. I'm not really there is much skill or planning involved. I haven't examined the code in enough detail to figure out whether there is anything more systematic than random numbers that determine the prices, but I think the hazards you run across on the way to the chosen fort are pretty much completely random.

An interesting bit of historical detail is that the Iroquois were traditionally the implacable enemies of the French since they had sided with their arch-enemy, the Huron, which is why your French trading party is in peril crossing Iroquois country on the way to one of the forts.

My hope is that when my son Charlie gets back from his first term at university that he might be able to help program in a brief snippet from a coureur de bois paddling song to add to the intro, or as part of a "travelling" interlude routine. He's my MC-10 sound programming expert. We generally use my MUSIC program to type in notes and then print a list of them as SOUND #,# statements to a text file using the MC-10 emulator's print to file function.

Here's a video of the program as it currently stands:

Another little program I made this month was a simple graphic demo. I subscribe to a number of Sinclair ZX81 Youtube channels. The ZX is the spiritual predecessor of the MC-10. It was obviously the inspiration for the kind of computer the MC-10 is-- an ultra-low-end entry level 8-bit. However, that market had largely disappeared by the time the MC-10 was released in 1983. The classic 8-bit home computers (Atari 800, Commodore 64, Coco) had simply come down enough in price to make ultra low budget machines unnecessary (except for poor flinty losers like me). But I digress. Unlike the MC-10, the ZX thrived in the brief heyday of ultra-low-budget-computing that it helped create. It has lots of fans and lots of Basic programs written for it. It also has a standard graphic resolution of 64 X 48 block graphics, which is a resolution the MC-10 also has in the form of its SG6 screen mode.

Youtuber ZX81 Programs ZX81 has put up a bunch of videos of simple, but interesting Basic programs written for the ZX81. One of these was called "ZX Type-in Program Pattern 2:"

Since the MC-10 and ZX81 share a 64X48 graphics resolution it was pretty easy to port the code I could see briefly listed in the video. The MC-10 lacks a PLOT command, but it can still do SG6 graphics with a few tricks using POKEs. My port uses a special Basic SG6 plotting routine I developed HIRES_SET&RESET2.TXT and not Greg Dionne's M/L plotting routine that I normally use in most of my SG6 programs. However, the MC-10 version is still faster than the venerable ZX81, but the ZX came first and blazed the trail!
Anyway, thanks to ZX81 Programs ZX81 for posting his videos and thanks to the archivists who have contributed all the wonderful free Basic software for the TRS-80 available on the Net. And thanks to Creative computing for it interesting simulation and my colleague Janice Tulk for the suggestion for another fun porting project!

Wednesday, 19 October 2016

October Retrochallenge 1: Deep Scan

As with many of my programming projects I got my inspiration for Deep Scan via some retro video watching on Youtube. I was browsing game videos from the NEC PC6001. I like keeping track of stuff about the NEC PC because it uses the same neon green wonder of a video chip, the Motorola MC6847, as the MC-10 (and Coco, Dragon, VZ200, etc.). Retro Gamer Z posts a lot of play-through videos for the NEC PC. I've subscribed to his channel, so I see when he posts new things. He posted a video for a game called "Deep Scan."
It was in hires and has lots of wonderful sound (the NEC has a fancy sound chip). Most certainly it was written in machine language. However, I thought the concept would work quite well in Basic. I also felt that I could probably bring all my best tricks to bear on making the animation fast. The resulting game, also called Deep Scan in honour of its inspiration, is pretty fast, although I am under no illusions that it is M/L fast. I'm just happy to make it as fast as possible within the restrictions of Micro Color Basic.
The main action of the program takes place in a tight FOR/NEXT loop starting at line 20--the number I commonly use for the main loop in most of my programs. The most commonly called subroutines usually start at line 1. Line 0 usually dimensions all the variables and then jumps to the startup routines, such as displaying the instructions, which are all located at the end of the program. I use only single letter variables and as few of them as possible, which includes recycling variables for multiple functions if possible. I declare the most commonly used variables in the DIM statement first, since I have been told they are looked up by the basic interpreter from a list in order of declaration or first use (i.e. further down the list takes longer to look up). I use pre-calculated arrays to store the correlated set-reset x/y locations for all the possible screen locations that a sub might be at. That way I can use an array to store each sub's location and the x/y locations for its continuously firing torpedoes, but when I need to re-fire from its current location, I don't have to calculate the new x/y location for its specific screen position. The program just consults the pre-calculated x/y array locations for the current position.

When it comes to checking for the characters hit by the depth charge I use a 255 element array for all possible characters with numbers stored in them usable by ON/GOTO or ON/GOSUB commands. The commands can then act as a single check for multiple possible actions depending on an character occupying the location to which the depth charge will move next. The next location is searched simply by PEEKING the screen memory location of that position and then consulting the array using the number returned. So, the blue water character of 175 is left as zero, whereas the characters for the subs have 1s put in their array locations, and torpedo character has a 2. This way, an ON/GOSUB line#1,line#2 routine can be used to either simply allow the depth charge to continue falling (the 0 value defaults to jumping past the ON/GOSUB options) or the sub hit or torpedo hit routines (line#1,line#2).

I use the same array to store numbers for the various actions of key inputs. Since the program only uses A for left and S for right and the Space key for depth charge, I just need to store a 1, 2 or 3 in each of the array locations corresponding to the ASCII values of each of these keys. Then, one ON/GOSUBline#1,line#2,line#3 will handle what to do when any of these keys is pressed. One ON/GOSUB therefore can do the work of three IF statements, which speeds the program's execution and provides Basic with something like the functionality of a SWITCH statement used in higher level languages.

Other speed measures include having torpedoes only check for hits once they move above the dark blue water.  Otherwise they just keep moving up. In other words they don't interact with other subs, other torpedoes, or the player's depth charge. They just keep moving up to the level of the Cyan sky. Once there, a check is made if they hit clear sky (Cyan) or the ship (Black). Sky=have the sub fire another shot. Black=ship hit. I think in the original NEC game shots can be blocked by other subs, torpedoes or the depth charge. By simplifying the complexity of the interactions between virtual objects, limiting the objects to single SET/RESET pixels or characters (the torpedoes), or single line PRINT@ strings (the subs and ship), some reasonably speedy animation in Basic can be achieved. In other words compromises must be made between speed and complexity, but I think virtual worlds can be created in Basic that are complex enough for reasonably good game play.

That being said, I know my games will have a limited possible interest for people attuned to modern computer gaming. Perhaps they might appeal to a very small number who remember the simple Basic type- games of the early 1980s with great affection. Perhaps they might only appeal to me. Yet, when it comes to a hobby it doesn't matter how many other people share one's interest. It was certainly fun in and of itself, to spend a number of hours crafting a "type-in" style game.  And it certainly took a few hours, and multiple false starts at thinking I had finished.  First I had to refine the startup screen a little to make it a little more interesting than the rudimentary one I started with:
This version also had a few fixes. I had to play enough games to notice that sometimes the bonuses could be randomly plotted in locations to the extreme right that the sub couldn't reach it with its depth charge. I also tweaked the number of lives awarded from a random number of 1 or 2, to just being 2. The game was tough enough that giving 2 lives if you survived 3 screens (when the bonuses appear) seemed reasonable, and more fair than a random number. Such fine-tuning can only come from playing the game a lot. I also eliminated a fourth size of ship, which I found too hard to play. You want to avoid unfairness and arbitrary death as much as possible, which can be tough to achieve in Basic games (or impossible, at least according to my Xbox jaded son).

My last major fix was that I noticed that I had a completely unnecessary array. I had a whole array for all the possible screen locations for the subs. Then I had an array which held a number that I incremented or decremented to point to that array. Stupid. I don't remember the rationale, but I just needed to store the actual screen locations for each sub and increment or decrement that, not a pointer to an array with  screen locations. It just goes to show that you never know whether you have fully streamlined a program. Continuous play and reexamination of the code can turn up efficiency improvements even after you think you've done everything possible. Most people will probably find it difficult to discern any substantial difference in speed between the various versions, But such subtle and obscure perfections are what hobbyists live for....

If you try the game try please let me know what you think (unless you are my son Charlie--XBox has ruined you boy, at least for the purposes of Basic Beta testing:). And any suggestions for game improvements or new features would certainly be welcome.  My next Retrochallenge post will be about two other programs I worked on earlier in October, Fur Trader and a graphics demo from the Sinclair ZX81.