Well it looks like I was perhaps a bit hasty in criticizing Micro Checkers by Tandy for the TRS-80 MC-10 (AKA GW BASIC Checkers-- see my last post). While I was investigating that program I also came across Tim Hartnell's Basic Checkers program. I was able to copy much of it from a scan and with a little editing to get it to work. The scan can be found here:
Then I modified it a little by flipping the board display routine. This helped put it into an orientation that allowed me to input moves from Micro Checkers to make the two programs play each other. It was Micro Checkers for the win! Way to go Tandy! I might have called it a weak A.I. but at least it's not as weak as Tim Hartnell's Checkers! I've seen someone on the net also try to put Tim Hartnell's Chess up against the 1K ZX81 chess program.
Hartnell's Chess, which I also have typed in, bugged out of the contest not too far in. From my experience it is a pretty weak and buggy version of chess.
Micro Checkers gave Hartnell's game a fairly good trouncing. But who knows, it is only one game. Perhaps I just caught Harrtnell's checkers on an off day. Here is a display of the final board layouts of the two programs running side-by-side:
The green pieces of Micro Chess (on the right) are the A.I. but on the left side those pieces are listed as "H"s (for human), since I was inputting those moves into Tim Hartnell's Checkers as my move (as the "Human" player). The computer's pieces were listed as "C"s, but they have all been removed. At least Hartnell's Checkers recognizes that it has been defeated, and I have to say that it has done so graciously. Hartnell's programs might not be strong, but they always have class. His checkers even posts the occasional random remark like, "Great move!" and "You got me!", which is a nice touch. But Hartnell's program was aimed at computers that probably had at least 16K, so such flourishes were possible. The fact that Micro Checkers cannot recognize its own victory doesn't take anything away from its more powerful play. Especially when one considers that it all fits in 4K!
Here's a rough breakdown of the match:
Addendum (2022):
I finally found the origin of Micro Color Checkers for the MC-10. It's just a rehash of Checkers from David Ahl's "BASIC Computer Games" compilation. Here's me playing the original, now also playable on the MC-10.
I had to fix a serious bug involving the computer kinging itself. I had to change line 1240 to make it GOTO 1310 instead of GOTO1420. Otherwise, it didn't remove the old piece position after moving it into the final row and kinging itself. This could result in a situation where it could spawn multiple kings!
I guess this post should be retitled to "David Ahl Checkers Versus Time Hartnell Checkers!"
I was bored, so I added cursor control input (AWSD) to "Micro Checkers" from Tandy. This was one of only a half dozen, or so, programs released by Tandy before they discontinued the TRS-80 MC-10 after only a year of production. Like all but the machine language hires pinball game provided by Tandy, it works in the limited 4K memory space of the unexpanded computer. My updated version of the program still runs in 4K. I had to use the RENUM command from MCX Basic, and some other code condensing tricks to get cursor input added while still keeping the revised program small enough to fit in 4K.
The original game did not play a very good game of checkers. You can see in this video that there are opportunities for multiple jumps that are missed. This got me to wondering whether there was a bug in the program, because it seemed a pretty serious deficiency for the A.I not to exploit opportunities for multiple jumps:
It's a funny little game. Some compromises obviously had to be made to get it to fit in 4K. For example, it doesn't prevent you jumping your own pieces or making 2 space "jump like" moves, even if there is no intervening opposing piece (perhaps someday when I'm bored again I'll try to add this). And you have to determine/declare your own game loss or end and hit break to re-run the program. Occasionally it completely misses an available jump and simply moves a piece, so enforced jumping is a bit spotty. As I noted, there also seemed to be a buggy routine that prevented the A.I. from doing multiple jumps. But I can't be sure if I somehow simply ended with a compromised version. I got my copy from the Internet of course, since my own original tape has gone to the great bit-rot bucket in the sky. Specifically from chazbeenhad's longstanding MC-10 site:
Chazbeenhad also helpfully provided a scan of the instruction booklet:
Perhaps the original program worked. But if that is not the case, then shame on Tandy for distributing a buggy program.
As I investigated the code of the program I was able to identify the routine that was supposed to process the possibilities for further jumps after an initial jump made by the computer:
I was able to determine that the FOR/NEXT loops in 360 and 370 were meant to be searches for an uncrowned jumping piece designated by S(X,Y)=-1 in line 360, or a crowned piece, designated by S(X,Y)=-2 in line 370. By inserting the STOP command and running the program I was able to determine that the 360 routine was not successfully searching and finding and acting on possible jumps. Each search called the subroutine at 400 and that routine made use of a routine at 210 to actuate the jumps. It used a similar check in line 400 as the main routine up in the 200s, so the problem had to be in the search in line 360. Initially I was able cut out the special 400 routine and just use the main jump search routine up in 200, to get multiple jumps to occur. You can see me demonstrating that here:
The only problem was that I had to add a bunch of fudges to the regular move and jump routine (at the 200s) to prevent certain kinds of behaviour. The general jump routine, would of course, process whether ordinary moves could be made in nearby squares, whereas I just wanted it to process further jump possibilities. I was able to add kludges to that prevented unwanted movements when that routine was called from 360 and 370, but this was not ideal as it added new variables, and I was already redlined for memory space. But while I was fiddling with the program I had also been investigating other BASIC checkers programs on the Net. I came across a piece of code for a GWBasic version of checkers that looked surprisingly similar to the code for the MC-10.
You can see that code listed here from a French language blog site:
Although obviously a more complex program with graphics for the pieces and board, and different variable names, you can see the basic structure of both programs are similar. I was able to locate the same multiple jump search routine:
1340 X=R(3):Y=R(4):IF S(X,Y)=-1 THEN B=-2:FOR A=-2 TO 2 STEP 4:GOSUB 1370:NEXT A 1350 IF S(X,Y)=-2 THEN FOR A=-2 TO 2 STEP 4:FOR B=-2 TO 2 STEP 4:GOSUB 1360:NEXT B,A 1360 IF R(0)<>-99 THEN LOCATE ,30:PRINT" TO "CHR$(65+R(3))","CHR$(49+R(4)):R(0)=-99:GOTO 1240 1365 GOSUB 3000:GOTO 1590 1370 U=X+A:V=Y+B:IF U<0 OR U>7 OR V<0 OR V>7 THEN 1400 1380 IF S(U,V)=0 AND S(X+A/2,Y+B/2)>0 THEN GOSUB 910 1400 RETURN
The most serious difference between the two code snippets is highlighted in red. The MC-10 version has FORA=-2TOASTEP4 instead of FOR A=-2 TO 2 STEP 4.
It was using the variable A in the FOR/NEXT loop and also using that variable, instead of 2 to define the scope of the search. It was also missing the NEXT A at the end of the line. Similarly in line 370 a NEXT for A was also missing. Instead, the programmer put a NEXT at line 380. This was probably an attempt to shave off some memory use by using a single NEXT for either of the IF routines used to select between un-kinged and kinged pieces. The problem is I think that the A was used instead of a 2 to define the search loop for un-kinged pieces. By changing that and adding the NEXTs at the end of the lines (and removing it from 380), I was able to get the program to make multiple jumps, probably in the way the original programmer intended.
I also added a check to the program to prevent it from allowing you to jump in a backward direction with an un-kinged piece after your first jump. So now with the added cursor key feature to select moves, hopefully the program is much more easy to play and perhaps a little more accessible for those interested in exploring early A.I. Basic game programming efforts. It's a petty amazing feat to fit a BASIC checkers game into 4K. Such early A.I. coding efforts deserve to be remembered.
Final note: Instead of entering -1,-1 to signal that you have ended a multiple jump sequence of you own, simply move the cursor onto a white square and hit <ENTER>. Cursor movement is by WASD. Use <ENTER> to select piece to move, then select place to move and hit <ENTER> again. If you make a mistake, just hit <ENTER> on a non-movement space and then restart the piece selection process.
Addendum
I think I might have found the original source of the code for both the GWBASIC and the Tandy Micro Checkers versions of Checkers. They both might be variations of a demonstration program from John Krutch's Artificial Intelligence for Small Computers, 1981. A link to this book can be found on the Internet Archive here:
I haven't done a complete line by line comparison of the 3 programs, but from Krutch's description of the algorithm, it seems to go about choosing moves in much the same way as I have observed from the play of Micro Checkers. The result is a very defensive approach. In short, it looks for jumps, then it looks for endangered pieces and then it looks for any move. Krutch mentions that his program doesn't allow multiple jumps, leaving that privilege to the human player. So I think that Micro Checkers might be a slightly improved version of the program that continues to process for jumps until there are none, after the initial jump. But all this is just speculation at this point. I'll have to follow up on this at some point in the future to confirm. Or someone else interested in the history of the development of such programs will have to.
Here's the progression: 1974 Maze War by Steve Colley for the Imlac PDS-1, 1978 Escape! by Muse for the Apple II, 1979 Ratrun by Code Works for the Commodore PET. These are the origins of the entire first person virtual world games of today. I wanted to add at least one to my collection of classic games for the TRS-80 MC-10. Maze War and Escape were machine language games. The first one was for an early minicomputer system. Here's the blurb from Wikipedia:
Maze, later expanded and renamed to Maze War, is a 3D networked first-person shooter originally developed by Steve Colley, Greg Thompson, and Howard Palmer for the Imlac PDS-1 computer. It was largely developed between the summer of 1972 and fall of 1973, at which point it included shooter elements and soon after was playable over ARPANET between multiple universities. It is considered the earliest first-person shooter; ambiguity over its development timeline has led it to be considered, along with Spasim (March 1974, on PLATO), to be one of the "joint ancestors" of the genre.
Very few people would have been directly influenced by Maze War. Most people would have got their first exposure to such games by playing either Escape! or Ratrun. The Digital Anitquarian has a nice write-up on Escape! He reveals that Lord British was inspired to write Akalabeth by Escape!.
These early attempts at rendering a virtual reality are hilarious when compared to today's ray-traced wonders, but every software revolution has to start somewhere. And Ratrun is part of that revolution-- a very BASIC part. Because it was first published in Cursor Magazine (#13) it would have got fairly wide distribution. People could simply borrow the magazine from a library and type it in for themselves. Very few would have been able to purchase Maze War, but very many might have had their first experience of a computer generated artificial reality in the form of the slowly rendered lines of Ratrun running on a school PET. As one commenter on the video of my version states "Such fun to see these old machines work like the ant that could." For more info see:
Another early classic game I got around to porting this week was the original Star Trek game from 1971 by Mike Mayfield written HP BASIC.
The source code I was able to locate was copyrighted in 1972, but the literature clearly indicates 1971 as the beginning of this prolific line of games. Mayfield must have continued to tweak the program just like everyone else. For one thing, I found a bug in it that affected the way that it handled the Photon Torpedo "trajectory calculator" menu option of the #7 "Computer" option. It seems to have a problem with a FOR/NEXT loop to allow you to do multiple calculations for the different Klingon battle cruisers in your quadrant. It runs into a NEXT without FOR error.
The code also seems to provide you automatically with a calculation for one of the cruisers when you first select the option but then flick a variable switch, which then means you must type in your own and the cruiser's sector coordinates for subsequent calculations. It almost seems like there was some uncertainty or reluctance on the part of Mayfield about introducing this powerful feature, which can guarantee a "one-shot kill" of the enemy. Part of the charm of the game as I played it in other (of the multiple) versions, is trying to develop the knack of figuring out shooting angles for your limited supply of photon torpedoes. This feature seems to have been left out by others.
In any case I fixed the bug by getting rid of the NEXT statement and simply looping back to the prompt that asks if you want to do further trajectory calculations. I also made an alteration to the symbol used for the Enterprise. I changed it from <*> to <^>. I've seen many version that use <E> too. The original one using the asterisk was difficult to distinguish from the asterisk stars, and looked sinister-- more like an enemy.
Finally, at the suggestion of Paul Berg, one of the Aussie members of the MC-10 Facebook group, I was able to obtain an old Australian Coco magazine listing for the MC-10 "Cattle Baron". Paul said he had some very fond memories playing this game back in the day. I had some fun cleaning up the text that I was able to copy from the scan. There probably hasn't been a working copy of this interesting board game/simulation of the Australian cattle industry for many decades. I added a little graphic of a cow multiplied across the screen to create a "herd," which I added to the round up screen. I also fixed what I think was a typo in the original listing for a little graphic of a bunch of blokes wearing Aussie hats at the "cattle auction." I think the graphic characters translated to letter keys to be pressed listed in a REM line just above the actual PRINT line was missing one character. By looking at the graphic in actual PRINT line and counting the jumbled graphics that appear in the place of what are supposed to be the actual graphic characters, I was able to see that a character was missing and guess which character it was.
Paul will hopefully add some of his copies of the magazine to the small number available on the Coco archives. That way I can look for a correction in subsequent issues, and perhaps find some more interesting type-in programs for the MC-10.
Well that wraps it up for my programming activities for the last couple of weeks. Now I just have to wait to hear about whether any of efforts earn any recognition from the "The Double-Do" contest being run by www.trs-80.org.uk
Greg Dionne has been working on a TRS-80 BASIC compiler. In the midst of corresponding with him about the developments we discussed my normal PEEK(2)ANDPEEK(17023) routine for continuous polling of key input. He then mentioned the "debounce" key delay, which could apparently be adjusted by way of a couple of POKEs. Here are his comments, which might be helpful for MC-10 BASIC programmers:
More
notes for you now that I'm looking at the keyboard routines.
1.
If you want the interpreter to go faster when a key is pressed, set the
debounce delay to 1. (POKE 16925,0 : POKE 16926,1).
2.
To examine the state of the BREAK key, (well, for the compiler at least), take
a PEEK at 16955. 255=PRESSED 0=NOT PRESSED
3.
The keys for the KEYSCAN are stored in 16945 to 16952. This gives you
access to each individual key. So you can tell if more than one key is
pressed and which keys.
4.
CONTROL, SHIFT and BREAK do not have dedicated memory allocated for them. You can
query the SHIFT key state via doing a PEEK(3). But the others will be
lost since the interpreter will immediately stomp on the keystrobe after
catching a key, so only SHIFT can (reliably) be caught this way. The
compiler will have no trouble querying the other states.
To
see all of this in action:
10
POKE 16925,0:POKE 16926,1 : REM MAKE IT SNAPPY
20
MC=16384:KS=16945
30
FOR I = 0 TO 7:POKE MC+I,PEEK(KS+I):NEXT
40
POKE2,254:POKE 16393,PEEK(3):REM CONTROL
50
POKE2,251:POKE 16394,PEEK(3):REM BREAK
60
POKE2,127:POKE 16395,PEEK(3):REM SHIFT
70
KY$=INKEY$:REM NEEDED FOR COMPILER ONLY
80
GOTO 30
I have added his debounce delay POKES (set to 1) to the following programs and updated my compilations:
DMCHASE
ADVENTUR
ALPHAFOR
BERZERK
BIGRED
BOARDER
CAVERAID
DANTE
DIGDUG
ELAVATOR
FROG
HEIANKYO
LODERUN
METEOR
MOUSE
PENGUINO
QBERT
ROVER
SABOT
SCRAMBLE
TOMB
XRALLY
NOSTRO
ABM
BRICKOUT
FARTGOAL
FLYWHEEL
GRIDFACT
LITTLEBR
MEANIES
MILLIPED
RCHASE
RESCUE
SHOPIFT
SPACEWAL
MCJOUST
PONGNEW
GOLDHUNT
GOTCHA
RCHASE
TANK
MILLI
CAR
It seems to make a noticeable difference. Movement seems much smoother and responsive. I'll be adding the POKEs to other programs over the next little while.
I've been working on a conversion of "Warren's World: The Lost Colony," which is an old game written in GWBASIC for the PC. The following is a description I found on the Net, which I have fixed up a little (I think it was translated from Russian or the author was a Russian speaker). I have also added a few highlighted terms for items that are needed during play):
Lost Colony is a turn-based economic strategy game that tells the story of the difficult fate of a human colony in a distant solar system. The game is based on the mechanics of the popular early 1980s game Hammurabi (the progenitor of the "construction and management simulation" video game subgenre), the essence of which boils down to the extraction and distribution of useful resources among the constantly growing population of the state/city/society.
There is a Lost Colony and the plot is as follows: In the distant future, during the exploration of deep space, a planet suitable for life was found, and since resources on Earth were dwindling, it was agreed to seek to colonize the newly discovered world. The first people sent were farmers and construction workers to prepare a new "home" to receive the rest of the settlers. But alas, everything did not turn out as planned. While the first starship was getting to the colony another war broke out on Earth and the colonists were left to fend for themselves. The pioneers, abandoned to their fate, suffered significant losses in the first years in a new place until they developed an ability to supply a minimum number of necessities. These had to be carefully issued per person. To organize production and distribution of these benefits an elected position was established-- "Chief Economist." This is the role the player takes on.
Goal: To hold the position of Chief Economist for 15 years (i.e. 15 moves).
Management is quite simple: At the beginning it is necessary to distribute people and robots (the latter are intended only to increase productivity-- machines cannot completely replace people) across five sectors of the "economy" (Transport, Mining, Energy, Farms and Manufacturing). Then, each turn, the computer asks a series of questions: What products will be produced (Robots, Transports, Manufacturing Plants, and Consumer goods) and in what quantities, what amount of "wages" will go to the workers, and what percentage of those wages will go to taxes. Nevertheless, the player is not limited to being a mere "accountant"-- You will also be asked to explore new territories. To do this, a map of the entire colony is displayed divided into regions; just indicate the regions you wish to select with the cursor and the computer will display information on the resources located there. But it is not enough just to explore new lands-- full-fledged mining and expansion of farming of these lands requires that they be populated. Finally, at the end of the turn, a certain event can happen (or maybe not)-- as a rule they are not very pleasant, such as: epidemic, explosion, etc.
Remember, in Lost Colony you will have two "opponents"-- these are the ever-growing population and proper adjustments to the wage level required each turn. If you cannot provide people with everything they need, you will lose your post as chief economist, which will automatically lead to the end of the game.
Summarizing all of the above: this game, despite the relative simplicity of mastering it, is not suitable for only "a couple of evenings" of play. It requires a very detailed approach, preferably with a calculator. Also be prepared for the fact that Lost Colony does not have much in the way of graphics and looks more like a specialized piece of software for financial workers.
My TRS-80 MC-10 version is a port of a GW BASIC version for the PC. It's a work in progress. My progress right now is hampered by my inability to play the game very well. So if there's anyone out there willing to do some play testing, the game can be played online here:
I'll leave it open to be played for a while during the debugging process before removing it until I can fully determine the original author's intentions regarding distribution.
Here is a screenshot of the PC version of the game map:
Here's another Description of the game that I found online:
Lost Colony is a resource management game which takes place on another planet, site of the first human settlement off Earth. As the economic administrator of the colony, your job is to keep the population happy and occupied, and to generally run things smoothly until the next supply ship arrives from Earth - in 15 years.
Each turn tasks you with allocating resources for the upcoming year, by dividing them among the five major industries (farming, mining, energy, manufacturing and transportation). These resources include human labor, robotic machinery and the planet's raw materials; production quotas can be diverted towards various goals, consumer goods handed out to keep the populace contented (and obedient), and new areas can be explored and settled.
Along the way, you'll have to deal with such misfortunes as labor strikes, famine, industrial accidents, plagues and natural disasters. Savvy governance will ensure that the struggling colony prospers, while continued mismanagement will have you booted out of office in disgrace.
I have ported Steve Wozniak's Apple II Integer BASIC source for a "Breakout" clone known as "Little Brick Out." This game was according to Wozniak, one of the first action games for a home computer. He had worked previously at Atari on the arcade cabinet version of Breakout. Part of his motivation in making the Apple I was to allow him to create such games not having to to use dedicated circuit boards but completely in software. This would allow games to be easily changed and customized by users. So it is interesting to note that in such a small game (it fits in less than 4K) the Woz provides the ability of the user to modify the screen colours. The second half of the video demonstrates this ability.
While I was at it, I added the ability to choose which keys to use for the up and down motion of the paddle. I thought this would be useful as the game is very quick and very tricky. Also, the MC-10 doesn't have a paddle input device like the original Apple did. I chose to make the screen paddle move in jumps of two, which makes it quick enough to jump from top to bottom after the ball is served. The paddle is 3 spaces tall so there is a little overlap for each move, but this can make it a little tricky to figure out how to best cover the space where the ball is likely heading on the left wall. I have only managed to almost clear the board twice in many dozens of games. Here is proof of one of these:
The game is very addictive, if only because the Woz has put in comments on your final score that range from "Terrible" to "Nearly Perfect". However, since the bricks on the first rows are worth far fewer points than those on the far right near the wall, you seem to get a disproportionate number of "terrible", "lousy" and "poor" scores. If you don't seriously whittle down those last two or three rows the "good and excellent" scores will likely remain out of reach. If you clear all the bricks you "Win the game!" There is no continuing to get the highest score possible. This is probably a blessing as the random motion of the ball will make hitting those last few blocks an exercise in extreme patience.
Apparently Wozniak programmed the game in less than half an hour. It was meant as a test for his Integer BASIC interpreter. However, as the Apple community moved on to Applesoft BASIC with floating point integer BASIC games were largely left behind, and so it has been difficult finding copies of the source. I have yet to locate a place to allow the game to be easily played in an emulator or online. Here is where I located the source in the 1978 "Apple II Redbook" reference Manual as an example program:
I have added the details of the game to my Type-In Mania website. You can't launch the code from there, as that is my faculty web space and I am trying to make a "Clean" page that only includes games permitted by original authors. So I hope to be contacting Mr. Wozniak very soon. I'll keep you posted.
My son Charlie and I have made a port of the Commodore VIC-20 Version of The Sword of Fargoal to TRS-80 MC-10. Because of the more limited nature of the graphic abilities of the MC-10 it renders its dungeons as ASCII text, which provides gameplay more like what Jeff McCord's unpublished forerunner game Gammaquest II on the Commodore PET might have been like.
It was quite a challenge to get the game working on the MC-10. I had to figure out how to use the BASIC's CLEAR command to allocate protected memory at the top of the memory map. The VIC version pokes the map for the current level into memory, and then just uses PEEK to plot that information back onto the text screen area as the player moves. One's surroundings are revealed only immediately around the player, which is what provides the "fog of war" view that has come to define the "rogue-like" genre of which Fargoal is one of the first.
A complexity that I had to deal with is that I also wanted to store a short M/L timer routine created by Darren Atkinson in higher memory. I needed this routine because the game uses the TI function of the VIC to give you 33 minutes to get back to the top level after you recover the sword somewhere on level 15-20. So I had to figure out how much memory I needed for both functions to fit.
I also had to work around the limitation of Darren's timer to only go for 15 minutes (or so) before it loops back to zero. So I changed the time keeping variables quite a bit. Now every time the monster movement routine is initiated, the time since it was last run is added to a time-keeping variable (T). This along with the fact that the timer must be turned off every time sounds (other than the step sound) occur means some time accuracy is lost. However, Charlie and I worked in some fudge factors to offset for the time when sounds are being played. On the whole our testing indicates that the program keeps a close approximation to the actual number of seconds passed. We erred on the side of generosity (we think), so you should actually get a little more than the standard 33 minutes to get out after collecting the sword.
The VIC version uses a loader program to load some custom fonts, with certain uncommon punctuation characters redefined as small graphic images of the character, monsters, stairs and pits, etc. Redefining the characters was not available on the MC-10 and since the punctuation characters used were somewhat arbitrarily assigned a fair bit of re-adjusting for aesthetic purposes had to occur. Instead of square and round brackets for monsters I used some of the unique punctuation characters, such as right arrow, up arrow and hash symbols. Instead of using the right and left slashes for gold, I assigned these to up and down staircases. Pits and ceiling holes became different round characters: O, 0, and @. Gold became the dollar sign. Magic/trap squares became the question mark. Each of these changes required careful searching and replacing of all the places in the code where the original character code was used. Fiddly, but after much testing, I think it has been done thoroughly.
The most important part of the conversion was changing McCord's ingenious dungeon drawing routine from a 22 X 23 character VIC screen to a 32 X 16 MC6847 screen. Also, all the movements for drawing those maps and moving the characters had to be switched from +22 -22 for up and down movement to +32 -32. The re-dimensioning was something I had done for other conversions so it went pretty smoothly.
PRINT commands also had to be switched from using the VIC's embedded control codes in strings method to using PRINT@ commands. When VIC listings are printed from WinVice, these codes generally get converted to periods. They are most commonly used for clearing the screen and in this game repositioning the cursor to the top left for printing messages on the top line "window", so it was not too hard to figure out. Watching Youtube playthroughs provided information about what was going on, on screen.
Youtube was also very helpful for replacing the sounds from the original. The VIC, of course, as a Commodore machine, uses a ton of PEEKs and POKES for all its sounds. All these routines were neatly lined up (for the most part) in one section of the code. By looking at which subroutine (death, theft, combat, pit falling, etc) one could guess what sounds were meant to be produced. Charlie, as usual, used his wonderful musical ear to recreate the main game refrain from listening to playthrough videos. He also went through the VIC code for clues from the various POKE commands to try to decipher musical note information and possible note duration. Through this combination he got the refrain to his satisfaction. With my tin ear, I'll leave it to others to judge the quality of his work.
After I was finished the main part of the conversion, the biggest thing was trying to speed up the program execution. The VIC has the ability to declare certain variables as Integer variables, which helps speed execution. You just have to put a % symbol after the variable name. The MC-10 only uses floats, so it was important to make sure that variable names used for graphic intensive actions, like moving monsters around on screen and tracking the character should be switched to single letter variable names (e.g. T for treasure was switched to GP and E for experience was switched to EX freeing up T and E for other uses). Single letter variables are interpreted by Basic more quickly. Also, removing redundant variables and using scratch variables can help keep the variable lookup list shorter and speed up execution. Finally, I declared all the graphic intensive variables in the initial DIM statements to speedup their execution. Variables declared earlier are placed earlier in the variable lookup table and therefore can be found and operated on faster.
After I had a working copy I thought it would be good to shoot the project by the original author to see how he felt about us sharing it more widely. The wikipedia page for Fargoal indicated that McCord was still vitally involved in modern variations of his classic program, and had collaborated with some programmers who had created a modern iPhone version. So I looked up the page for the new app and left a message about my project. A few days later McCord got back to me. He asked some questions about the project and when he was sure that it was just a retrocomputing homage he generously gave his blessing to share the game with others. All he requested was that his copyright be updated (1982-2020) and a note be made of his permission. So I replaced the "Epyx presents" part of the old title screen with a reference to McCord's permission to create the game as a retrocomputing "pet project."
He told me that he appreciated my enthusiasm for his original game and desire to bring it to the TRS-80. He also mentioned that he actually used a TRS-80 (Model 1 or 3 as it turned out) at school as one of his first computers to learn BASIC coding as a teenager in Lexington, KY. But his dad bought a PET, which he ended up using to create the precursor to Sword of Fargoal, Gammaquest II, while he was in high school.
That program was never published. It was my hope in pursuing this project that not only would I get another working program for my favourite orphan 8-bit system from the early 80s, but also a program that is somewhat evocative of that now missing classic precursor program to Fargoal. So if you have a hankering to relive what playing Gammaquest II might have been like you might find that our version fits the bill. It can be played online here:
This line is the one that initiates the sword (and gold) stealing routine. The first part of the IF seems to check for whether you are being attacked by a non-humanoid monster (D=0) or a humanoid monster (D=1). Then it checks whether you have gold (T>0) or you have found the sword (SF=1). But by not having brackets around the (T>0ORSF=1) it means that no matter whether a humanoid or non-humanoid monster attacks you, the sword can be stolen. We found that after collecting the sword (see last video below) it was very hard to make it to the top level without sometimes being attacked. Then if the monster is less than half as weak or is stronger than you, the sword will immediately be stolen. At the deepest levels, just after you have stolen the sword there will be many chances for strong monsters to jump you--They move fast and you will be struggling to make it to safety. As you go higher, you will start to encounter weaker monsters but you will also be feeling increasingly rushed as time runs out, so it is easy to rush to find stairs and end up being jumped by a weak beastie. Since the sword immediately goes all the way back to its original level, it's really game over, which seems unfair. So we changed it to:
McCord seemed to intend that at higher levels, even weaker monsters could try to make a grab for the sword. This way those levels wouldn't just be a cake walk, but it seems excessive that if you stumble across *any* monster (especially unseen assassins or dimension spiders), it's game over. It makes more sense to us that you should certainly be wary of being jumped, but it shouldn't be an exercise in perfection. And there should be a real possibility to recover, so we changed it so that the sword is relocated on the current level. You will have to leave the level and return to it to make the sword reappear, so it represents a frustrating, possibly fatal, delay, but not instant failure. I'm not sure if we have disrupted some critical element of the game dynamic, but we will continue our testing and try to determine if it results in a slightly more enjoyable game.
We also considered nerfing the movement for monsters at levels below 15. At level 20 the monsters have 1 to 1 movement turns with you, whereas at level 1 they move only every 19 turns.
2 GD=0:P1=0:L1=0:R1=50:S=20-L:IFS<1THENS=1
We thought it might be nice to change it to:
2 GD=0:P1=0:L1=0:R1=50:S=20-L:IFS<5THENS=RND(3)+1
It seemed to us that if you got stuck with the sword being on a lower level than 15, that should be enough of an increased challenge in itself. It didn't seem fair that the monsters should also become ludicrously difficult to avoid (and your movement excessively slow). But we tested playing it with one to one movement, and it wasn't impossibly slow, and there were some techniques for avoidance, so we decided to leave it. McCord seemed to want to allow players to also have other goals than simply getting the sword, such as testing themselves at going deeper.
We also ran across a bug in line 262 noticed by some of the early reviewers of the VIC version of the game.
This error occurs if a currently searched monster (variable M) is not found among the list of monsters stored in N(J). This check occurs after combat has been initiated by you. For some reason no monster location M has been properly assigned yet if you jump on a monster immediately after level startup so we also initiate M to a monster location at level startup.
We added some instructions outlining the basic operations of the game that you can access at program startup by hitting the H key. We also highlighted the key letters used for the various spells on the Magic report screen. So now, anyone should have the basics in hand for playing our version of the game (such as online via the link above) without having to consult the manual. For example, the 8-way motion of the joystick is recreated using the keys:
QWE
ASD
ZXC
SPACE is the "panic button." The S key operates as down key so you can also use the WASD combination for basic motion. So we relocated the "S" for shield spell to the ENTER key.
Here's Shot97 having trouble trying to win the original Fargoal. Hopefully my edits might resolve some such frustrations:
Addendum to the Addendum
We think we found another bug in the following routine (this is the original VIC source):
The fl variable is initialized to zero, but only at line 283 inside the loop processing the movement of the non-humanoid monsters on a level. A similar loop begins at line 286 for the humanoid monsters. However, it doesn't initialize the fl variable to zero. This variable is the trigger for the teleport routine being jumped to if player hits the panic button while being attacked by a monster. This jump to the teleport occurs in the IF commands at lines 283 and 288 for the non-human and humanoid monsters respectively. Everything is fine if there are at least some non-humanoid monsters to process on a map. That means the fl variable gets reset to 0. But the "goto286" in line 282 can lead to the entire non-humanoid monster processing routine being skipped. In that case, the fl variable never gets reset. So in the rare occurrence where you initiate a panic teleport when attacked, and there happens to be no non-human monsters left on a level, you can end up automatically teleporting again and again every time the monster movement routine is processed. And don't try to get out of the problem by trying to take a stairway and go to another level, because that will lead to a NF (next without for) error in line 12. The reason for that is that the "if fl=1 then 52" command sequence is a jump back up to line 52 (the main loop) from within a FOR/NEXT loop for processing each of the monster types. In other words, the FOR/NEXT loop is never formally completed/properly exited, which can lead to all sorts of confusion in the interpreter about how to process subsequent NEXTs, as one can see here in this test worked out by Charlie on the Vic emulator:
Never reinit a FOR loop inside other FOR loops!
This is likely a very rare occurrence and it is possible that something in the original code that we somehow messed up prevented it from occurring. But we fixed it in our version by properly shutting down the FOR/NEXT loop before jumping back to the main loop. We also initialize the fl variable at the top of the monster movement routine (line 282) before either the monster-type loops are entered. This is okay since any panic button aborts the entire routine (282-290), so it really only needs to be initialized once. This will also mean a speedup of the first loop as fl will not be reinitialized each time that loop is run.
If you make it, you get a message that says "Your quest is complete!" and then a screen of your overall statistics. If the clock runs out, next time you change levels, you get a message that says "out of time!" but then it takes you to the same statistics screen. Except for that brief flash of "Out of time!" or "Your quest is complete!" you wouldn't really be able to tell if someone won the game or not.
In our version if time runs out that message will stay at the top of the statistics screen. If you win a little refrain will play before you are taken to the stats screen. You can see this in the video of my son Charlie actually winning the game. Thanks to Charlie and his patience and dexterity, I think I can know call this project complete. The Sword has been recovered! Peace is returned to the Great Forest lands.
Charlie for the Win!
Addendum to the Addendum to the Addendum (2023/12/04)
