Click here to Skip to main content
Click here to Skip to main content

Star Trek 1971 Text Game

, 29 Jul 2008 LGPL3
Rate this:
Please Sign up or sign in to vote.
A reworking of the 1971 Star Trek text game using C#

A Bit of History

Two years after the original series was canceled in 1969, high school senior Mike Mayfield was busy keeping the Star Trek universe alive by feeding punched paper tape into a Sigma 7 in an effort to bring the crew of the Enterprise and the Klingon Empire to life on a 10 character-per-second teletype terminal. Soon after Mike ported his game to HP BASIC, it entered the public domain. From there, early computer enthusiasts enhanced and rewrote the game for every flavor of mini and microcomputer BASIC imaginable and beyond.

I remember encountering versions of the game back in the early 80s when I was a little kid trying to learn BASIC on my IBM PCjr. Back then, computer books and magazines distributed programs in printed form. Meaning, you had to type them in to play the games. It was a pain in the ass, but the process encouraged you to tinker. It motivated you to learn to code and to tweak or even improve the programs you were entering in.

Every BASIC game book that I picked up contained some version of the Star Trek game. I recall loading it up a few times, but each time I ended up staring at the screen in utter confusion. "How the heck is this Star Trek?" I remember thinking. I couldn’t figure out how to play it.

By the time I entered high school, I had graduated from BASIC and moved onto to bigger and better things like C and C++. But, on occasion, I often wondered about the Star Trek text game. What made it so popular? After learning about the history that I touched upon above, I decided to dig it up and take a second look.

After a bit of web surfing, I came across Mike Mayfield’s original port to HP BASIC. Here’s a snippet of the code:

100  REM *****************************************************************
110  REM ***                                                           ***
120  REM ***     STAR TREK: BY MIKE MAYFIELD, CENTERLINE ENGINEERING   ***
130  REM ***                                                           ***
140  REM ***        TOTAL INTERACTION GAME - ORIG. 20 OCT 1972
150  REM ***                                                           ***
160  REM *****************************************************************
170  GOSUB 5460
180  PRINT "                          STAR TREK "
190  PRINT "DO YOU WANT INSTRUCTIONS (THEY'RE LONG!)";
200  INPUT A$
210  IF A$ <> "YES" THEN 230
220  GOSUB 5820
230  REM *****  PROGRAM STARTS HERE *****

Ah, good old line-numbered BASIC. It’s all coming back to me now. Those line numbers were there to provide targets for GOTO and GOSUB statements. But, line numbers made editing a tad difficult. It was convention to enter in line numbers that were multiples of 10. That way, as you developed the program, you could go back and insert up to 9 additional statements in between existing lines without reworking all the GOTO/GOSUB references. If you needed to insert more than 9 lines, I remember a special feature in the BASIC editor on my PCjr. It would append a zero to all line numbers and all line number references throughout the program. Meaning, you could now insert up to 99 lines. Couldn’t they just renumber the program in multiples of 10? Nah. The PCjr wasn’t powerful enough for that.

If you’re wondering about “Centerline Engineering,” it was an imaginary company that Mike Mayfield coined to give his BASIC projects a level of prominence to those reading the remarks section.

With code in hand, I really wanted to play the game. I’m sure that there are HP BASIC interpreters out there for modern machines, but what fun would that be. Before I played it, I wanted do my own port. This game was born in the hobbyist era. It was made to be reinterpreted and enhanced as it traded handed. I wanted to bring back part of those long-lost magical days of type-in programs.

My first impression of the code was "what’s with all the single letter variable names?" First I thought it was a limitation of HP BASIC, but then I noticed the occasional 2-letter names. I guess 2 is better than 1. Everything is also in caps. Take a look at this line:

2140  T=T+1

That line increments T. But, due to the caps, I feel like the code is screaming at me. ASIGN THE SUM OF T AND 1 BACK TO T DAMN IT! Also, I’m so used to writing t++ or t += x that I forgot about the expanded notation. In fact, entering 7th grade having mastered BASIC, I found myself really confused when my math teacher introduced us to solving simultaneous equations. For instance, find the value of X in this equation:

X = 2X - 6

That was the first time I was introduced to the concept of operator overloading. The equals-sign can mean variable assignment or numerical equivalence depending on the context.

Here’s a cool block of code that I noticed:

4550  IMAGE  8(X,3A)
4560  IMAGE  8(X,3A),8X,"STARDATE",8X,5D
4570  IMAGE  8(X,3A),8X,"CONDITION",8X,6A
4580  IMAGE  8(X,3A),8X,"QUADRANT",9X,D,",",D
4590  IMAGE  8(X,3A),8X,"SECTOR",11X,D,",",D
4600  IMAGE  8(X,3A),8X,"ENERGY",9X,6D
4610  IMAGE  8(X,3A),8X,"PHOTON TORPEDOES",3D
4620  IMAGE  8(X,3A),8X,"SHIELDS",8X,6D

These are not executable statements. They’re strings that can be referenced in PRINT commands. The unquoted symbols get substituted with values of variables. It’s conceptually similar to C-style printf() format placeholders. I didn’t realize that BASIC offered such a rich numerical formatting notation.

As I continued to examine the source, I found some statements that didn’t make sense. For instance, even though you don’t have to declare variables before you use them, you still need to specify the dimensions of arrays. I came across some arrays that were never allocated as such. Ultimately, I decided to seek out a better basis for my port.

After a bit of Googling, I found a cleaned up version that maintained the majority of Mike Mayfield’s code. Some of it was reworked, probably to enable it to run on modern versions of BASIC. For instance, those cool IMAGE statements were dropped and replaced with sets of simpler PRINT commands. The variable names appear virtually identical, but at least they are all accounted for in this version.

Porting the Game

Next, I had to decide what language to port it to. Staring at that BASIC code reminded me that C# brought goto back into the mainstream. Would it be possible to do an exact line-by-line port from BASIC to C#? Apparently so... and the result is some of the sickest code I’ve ever keyed into a computer. Want a comparison? Here’s a segment of BASIC code:

2950  PRINT "TORPEDO TRACK:"
2960  LET X=X+X[1]
2970  LET Y=Y+X[2]
2980  IF X<.5 OR X >= 8.5 OR Y<.5 OR Y >= 8.5 THEN 3420
2990  LET V[4]=X
2991  LET V[5]=Y
2992  GOSUB 9000
2993  PRINT
3020  IF A[INT(X+.5),INT(Y+.5)]#0 THEN 3080
3060  GOTO 2960
3080  IF A[INT(X+.5),INT(Y+.5)]#2 THEN 3230
3120  PRINT "*** KLINGON DESTROYED ***"
3130  LET P[1]=P[1]-1
3140  LET P[3]=P[3]-1
3150  IF P[3] <= 0 THEN 4040
3160  FOR I=1 TO 3
3170  IF INT(X+.5)#K[I,1] THEN 3190
3180  IF INT(Y+.5)=K[I,2] THEN 3200
3190  NEXT I
3200  LET K[I,3]=0
3210  GOTO 3370
3230  IF A[INT(X+.5),INT(Y+.5)]#4 THEN 3290
3270  PRINT "YOU CAN'T DESTROY STARS SILLY"
3280  GOTO 3420

And the C# version:

_2950: Console.WriteLine("TORPEDO TRACK:");
_2960: X = X + _X[1];
_2970: Y = Y + _X[2];
_2980: if (X < .5 || X >= 8.5 || Y < .5 || Y >= 8.5) goto _3420;
_2990: _V[4] = X;
_2991: _V[5] = Y;
_2992: _9000();
_2993: Console.WriteLine();
_3020: if (_A[(int)(X + .5), (int)(Y + .5)] != 0) goto _3080;
_3060: goto _2960;
_3080: if (_A[(int)(X + .5), (int)(Y + .5)] != 2) goto _3230;
_3120: Console.WriteLine("*** KLINGON DESTROYED ***");
_3130: _P[1] = _P[1] - 1;
_3140: _P[3] = _P[3] - 1;
_3150: if (_P[3] <= 0) goto _4040;
_3160: for(I = 1; I <= 3; I += 1) {
_3170:   if ((int)(X + .5) != _K[(int)I, 1]) goto _3190;
_3180:   if ((int)(Y + .5) == _K[(int)I, 2]) goto _3200;
_3190: ;} I = 3;
_3200: _K[(int)I, 3] = 0;
_3210: goto _3370;
_3230: if (_A[(int)(X + .5), (int)(Y + .5)] != 4) goto _3290;
_3270: Console.WriteLine("YOU CAN'T DESTROY STARS SILLY");
_3280: goto _3420;

To simulate line numbers, each line starts with a label consisting of an underscore followed by a number. That works fine for GOTO, but what about GOSUB? Examine line 2992. Subroutines were replaced with methods. That almost worked. In BASIC, you’re not forced to RETURN from subroutines. You can leave them via GOTO. That was used only in the case that the player is destroyed to send them back to the beginning of the program to start over. I replaced that GOTO with a return statement that passes a flag back to the caller. The caller inspects the flag and jumps back to the program start if need be. I also discovered that at one point, there is a GOTO that jumps into a FOR loop. C# won’t let you jump to a label in a sub-block of code. I transformed the FOR loop into a GOTO loop to make C# happy.

All the variables in the BASIC program, including the arrays, are real number type. However, in BASIC, an array and a scalar can share the same name; the interpreter is able to sort it all out. But, C# is less kind. To solve the problem, I prefixed array names with underscores. Also, arrays in BASIC are indexed from 1 instead of 0. To compensate, I increased the length of all arrays by 1. Index 0 is never used.

When I started testing my port, I noticed some string formatting problems. Examine the following BASIC line:

2726  PRINT TAB(41);"(";

That means: Print 41 spaces followed by left-parenthesis. That was easy to translate, but the intension was to push the left-parenthesis onto the next line by letting it wrap around the console. I cleaned some of this stuff up. There are also some tables that get printed in the game. I reformatted them a bit to make them easier to read.

One other thing: notice that in this type of BASIC, # indicates not-equal-to. It took me a while to realize why they chose that symbol. # resembles ≠.

Entering the Star Trek Universe

Now, I was ready to play the game. As I mentioned above, I never understood the rules before. Luckily, when you run the program, it gives you the option of viewing instructions. I studied them carefully. But, the only way to really understand what to do is to play the game. Here’s a walkthrough:

                          STAR TREK



ENTER 1 OR 2 FOR INSTRUCTIONS (ENTER 2 TO PAGE)

ENTER SEED NUMBER
INITIALIZING...

YOU MUST DESTROY 17 KINGONS IN 30 STARDATES WITH 3 STARBASES

-=--=--=--=--=--=--=--=-
    *
                         STARDATE  2100
                *     *  CONDITION GREEN
            <*>          QUADRANT  5,2
    *                    SECTOR    5,4
                         ENERGY    3000
                         SHIELDS   0
                   *     PHOTON TORPEDOES 10
-=--=--=--=--=--=--=--=-
COMMAND

The game makes itself known by printing out its title. Then, it asks you if you want to view instructions. Every prompt in the game demands a number. If you hit Enter, zero is assumed. In this case, I hit Enter to skip the instructions. Next, it asks for a seed number to initialize the randomizer. This is an artifact of BASIC. It doesn’t really have an effect in C#. In BASIC, just as in C#, the randomizer could have been initialized based off the system time. If that was not an option, they should have taken advantage of the instructions prompt. When the instructions prompt appears, it could have entered a loop that timed how long it took the user to enter a value. That duration could have been used to initialize the randomizer. Again, I simply pressed Enter to skip it.

Next, it prints out my mission. I have to destroy 17 Klingon (note the game misspells it here) ships in 30 units of time with 3 starbases. Then it runs the short range scanner. The short range scanner displays the current quadrant. The game takes place in an 8×8 quadrant grid. Each row and column is numbered 1 to 8. The text on the right indicates that I am in quadrant (5,2). Each quadrant is partitioned into an 8×8 sector grid. The Enterprise is located at sector (5,4). On the quadrant display, <*> is the Enterprise. The remaining *’s are stars. Each = mark on the top and bottom horizontal-line dividers indicates a column. If you count, you’ll find that the Enterprise is in column 5. If you count the rows, you’ll find it’s in row 4. Hence, within this quadrant, the Enterprise is in sector (5,4) as specified.

The goal is seek out quadrants containing Klingon ships and destroy them. Let’s begin by doing a long range sensor scan (option 2):

COMMAND 2
LONG RANGE SENSOR SCAN FOR QUADRANT 5,2
-------------------
| 008 | 008 | 004 |
-------------------
| 006 | 005 | 007 |
-------------------
| 001 | 104 | 113 |
-------------------

This table summarizes 9 quadrants. The center quadrant is your current quadrant. The digits indicate the number of Klingon ships, the number of starbases and the number of stars. In our quadrant, there are no Klingon ships and no starbases, but there are 5 stars. Stars act as annoying obstacles as I’ll demonstrate later on. South of us, there is a quadrant containing 1 Klingon ship. Let’s head there. But, first we need to raise shields (option 5):

COMMAND 5
ENERGY AVAILABLE = 3000
NUMBER OF UNITS TO SHIELDS 500

It asks me how much energy I want to devote to the shields. I entered 500. If I run out of energy, I lose the game. Starbases replenish energy. They also restock photon torpedoes and repair damage. To see how much energy I have left, I’ll run a short range scan again (option 1):

COMMAND 1
-=--=--=--=--=--=--=--=-
    *
                         STARDATE  2100
                *     *  CONDITION GREEN
            <*>          QUADRANT  5,2
    *                    SECTOR    5,4
                         ENERGY    2500
                         SHIELDS   500
                   *     PHOTON TORPEDOES 10
-=--=--=--=--=--=--=--=-

Now, let’s head south. Navigation requires 2 parameters: direction and distance. It’s a polar coordinate system, but an unconventional one. Direction is specified using this:

4    3    2
 `.  :  .'
   `.:.'
5---<*>---1
   .':`.
 .'  :  `.
6    7    8

Angle goes from 1.0 (inclusive) to 9.0 (exclusive). Note that the y-axis points downwards. So, although it appears to be a counterclockwise angle system, it’s actually clockwise. You also need to consider the aspect ratio. Each column is 3 characters wide, but each row is only 1 character high. This means that it’s not a circular coordinate system. Rather, it’s a swashed oval.

Distance is measured in warp factor units. Such a unit is equal to the length/height of a quadrant. To move to an adjacent sector, you need to move a distance of 1/8 = 0.125. I’m going to move south (angle 7.0) a distance of 1 warp factor. Navigation is option 0:

COURSE (1-9) 7
WARP FACTOR (0-8) 1

DAMAGE CONTROL REPORT: WARP ENGINES DAMAGED

-=--=--=--=--=--=--=--=-
       *
                         STARDATE  2101
                *        CONDITION RED
            <*>          QUADRANT  5,3
                         SECTOR    5,4
 *                       ENERGY    2497
          *              SHIELDS   500
            +++          PHOTON TORPEDOES 10
-=--=--=--=--=--=--=--=-

Navigation automatically runs a short range scan. Note that I moved from quadrant (5,2) to quadrant (5,3). Also, notice that is says that my warp engines are damaged. Parts of the Enterprise fail spontaneously. As you navigate around, they slowly get repaired. Let’s get a damage report (option 6):

COMMAND 6

DEVICE        STATE OF REPAIR
WARP ENGINES  -3
S.R. SENSORS  0
L.R. SENSORS  0
PHASER CNTRL  0
PHOTON TUBES  0
DAMAGE CNTRL  0
SHIELD CNTRL  0
COMPUTER      0

A value of 0 indicates normal operation. Less-than 0 is damage. Greater-than 0 indicates that the component is working above normal.

The short range scan above shows a Klingon ship (the triple-plus). I’m going to use the computer to help me target the ship (option 7 followed by option 2):

COMMAND 7
COMPUTER ACTIVE AND AWAITING COMMAND 2
DIRECTION = 7
DISTANCE  = 4

ENTER 1 TO USE THE CALCULATOR

Photon torpedoes are fired using the same direction and distance coordinate system as is used for navigation. The computer gave me the coordinates. Then it asks if I want to use the navigation calculator. The navigation calculator asks you to enter the coordinates of 2 quadrants and it will output direction and distance between them. I’ll press Enter to indicate I am not interested in doing this. Now, let’s fire the torpedo (option 4):

COMMAND 4
TORPEDO COURSE (1-9) 7
TORPEDO TRACK:
 5,5
 5,6
 5,7
 5,8
*** KLINGON DESTROYED ***
COMMAND 1
-=--=--=--=--=--=--=--=-
       *
                         STARDATE  2101
                *        CONDITION GREEN
            <*>          QUADRANT  5,3
                         SECTOR    5,4
 *                       ENERGY    2497
          *              SHIELDS   500
                         PHOTON TORPEDOES 9
-=--=--=--=--=--=--=--=-

The game outputs the track of the torpedo. In this case, it hit the target. If the computer gets damaged, you have to estimate the direction of the Klingon ship yourself. It may take a few tries. The torpedo track will help you refine the direction. Also, sometimes a torpedo randomly diverts a bit from the specified direction.

Let’s get a status report using the computer (option 7, option 1):

COMMAND 7
COMPUTER ACTIVE AND AWAITING COMMAND 1

   STATUS REPORT

NUMBER OF KLINGONS LEFT  = 16
NUMBER OF STARDATES LEFT = 29
NUMBER OF STARBASES LEFT = 3

DEVICE        STATE OF REPAIR
WARP ENGINES  -3
S.R. SENSORS  0
L.R. SENSORS  0
PHASER CNTRL  0
PHOTON TUBES  0
DAMAGE CNTRL  0
SHIELD CNTRL  0
COMPUTER      0

One Klingon ship down, but my warp engine is still damaged. Let’s do a long range scan:

COMMAND 2
LONG RANGE SENSOR SCAN FOR QUADRANT 5,3
-------------------
| 006 | 005 | 007 |
-------------------
| 001 | 004 | 113 |
-------------------
| 002 | 005 | 002 |
-------------------

I want to go east. The starbase there, indicated by the center 1, can repair my warp drive. I’ll try to navigate there:

COMMAND 0
COURSE (1-9) 1
WARP FACTOR (0-8) 1
WARP ENGINES ARE DAMAGED, MAXIMUM SPEED = WARP .2
COURSE (1-9) 1
WARP FACTOR (0-8) .2
-=--=--=--=--=--=--=--=-
       *
                         STARDATE  2101
                *        CONDITION GREEN
               <*>       QUADRANT  5,3
                         SECTOR    6,4
 *                       ENERGY    2501
          *              SHIELDS   500
                         PHOTON TORPEDOES 9
-=--=--=--=--=--=--=--=-

As you can see, when the warp drive is damaged, I can only move 1 sector at a time.

DAMAGE CONTROL REPORT: L.R. SENSORS DAMAGED

-=--=--=--=--=--=--=--=-
       *
                         STARDATE  2101
                *        CONDITION GREEN
                  <*>    QUADRANT  5,3
                         SECTOR    7,4
 *                       ENERGY    2505
          *              SHIELDS   500
                         PHOTON TORPEDOES 9
-=--=--=--=--=--=--=--=-
COMMAND 0
COURSE (1-9) 1
WARP FACTOR (0-8) .2
-=--=--=--=--=--=--=--=-
       *
                         STARDATE  2101
                *        CONDITION GREEN
                     <*> QUADRANT  5,3
                         SECTOR    8,4
 *                       ENERGY    2509
          *              SHIELDS   500
                         PHOTON TORPEDOES 9
-=--=--=--=--=--=--=--=-
COMMAND 0
COURSE (1-9) 1
WARP FACTOR (0-8) .2
-=--=--=--=--=--=--=--=-

                  +++    STARDATE  2102
    *           *        CONDITION RED
<*>                      QUADRANT  6,3
                         SECTOR    1,4
               >!<       ENERGY    2513
                         SHIELDS   500
                      *  PHOTON TORPEDOES 9
-=--=--=--=--=--=--=--=-

I managed to get over there, but now my long range scanner is damaged. Note that each time you cross a quadrant boundary, the stardate advances. I have to destroy all the Klingons in the time restriction of my mission.

The >!< symbol indicates a starbase. If I navigate next to it, the Enterprise will automatically dock at which time I’ll get everything repaired. But, if I try to navigate there, the Klingon ship will fire at me. I can’t send out a photon torpedo because of the stars. The stars will obstruct the track. Let me check on those repairs:

COMMAND 7
COMPUTER ACTIVE AND AWAITING COMMAND 1

   STATUS REPORT

NUMBER OF KLINGONS LEFT  = 16
NUMBER OF STARDATES LEFT = 28
NUMBER OF STARBASES LEFT = 3

DEVICE        STATE OF REPAIR
WARP ENGINES  0
S.R. SENSORS  0
L.R. SENSORS  0
PHASER CNTRL  0
PHOTON TUBES  0
DAMAGE CNTRL  0
SHIELD CNTRL  0
COMPUTER      0

Nice. The Enterprise is back to normal. I’ll try using my phasers to hit the Klingons (option 3):

COMMAND 3
PHASERS LOCKED ON TARGET.  ENERGY AVAILABLE = 2513
NUMBER OF UNITS TO FIRE 500
19 UNIT HIT ON ENTERPRISE FROM SECTOR 7,2
   (480 LEFT)
67 UNIT HIT ON KLINGON AT SECTOR 7,2
   (132 LEFT)

The Enterprise was hit. My shields dropped a small amount. The Klingon ship was damaged as well. I’ll fire again:

COMMAND 3
PHASERS LOCKED ON TARGET.  ENERGY AVAILABLE = 2013
NUMBER OF UNITS TO FIRE 1000
16 UNIT HIT ON ENTERPRISE FROM SECTOR 7,2
   (464 LEFT)
100 UNIT HIT ON KLINGON AT SECTOR 7,2
   (31 LEFT)
COMMAND 3
PHASERS LOCKED ON TARGET.  ENERGY AVAILABLE = 1013
NUMBER OF UNITS TO FIRE 300
5 UNIT HIT ON ENTERPRISE FROM SECTOR 7,2
   (458 LEFT)
62 UNIT HIT ON KLINGON AT SECTOR 7,2
   (0 LEFT)
*** KLINGON AT SECTOR 7,2 DESTROYED ***
COMMAND 1
-=--=--=--=--=--=--=--=-

                         STARDATE  2102
    *           *        CONDITION GREEN
<*>                      QUADRANT  6,3
                         SECTOR    1,4
               >!<       ENERGY    713
                         SHIELDS   458
                      *  PHOTON TORPEDOES 9
-=--=--=--=--=--=--=--=-

I fired twice, which severely lowered my energy level. Phaser strength is a measure of the distance between the Enterprise the target. It probably would have been better to navigate north for a clear path for a photon torpedo. Luckily, I can dock with the starbase to replenish my energy:

COMMAND 0
COURSE (1-9) 7
WARP FACTOR (0-8) .25
-=--=--=--=--=--=--=--=-

                         STARDATE  2102
    *           *        CONDITION GREEN
                         QUADRANT  6,3
                         SECTOR    1,6
<*>            >!<       ENERGY    716
                         SHIELDS   458
                      *  PHOTON TORPEDOES 9
-=--=--=--=--=--=--=--=-
COMMAND 0
COURSE (1-9) 1
WARP FACTOR (0-8) 1
WARP ENGINES SHUTDOWN AT SECTOR 6,6 DUE TO BAD NAVIGATION
SHIELDS DROPPED FOR DOCKING PURPOSES
-=--=--=--=--=--=--=--=-

                         STARDATE  2103
    *           *        CONDITION DOCKED
                         QUADRANT  6,3
                         SECTOR    5,6
            <*>>!<       ENERGY    3000
                         SHIELDS   0
                      *  PHOTON TORPEDOES 10
-=--=--=--=--=--=--=--=-

The starbase takes away all my shield energy before giving me back 3000. If the game didn’t do this, the player could get infinite shield strength by repeatedly docking and transferring energy to the shields.

Also note that I docked by crashing into the starbase. While you are within a quadrant, you can’t pass through stars, ships and starbases. However, after leaving the current quadrant, those are no longer obstacles. In fact, the positions of stars, starbases and Klingon ships within a quadrant is not determined at the start of the game. Rather, the positions are invented at the time you enter a quadrant. It creates the illusion that stars, starbases and Klingon ships can move around within a quadrant. Note that they can never move out of a quadrant.

COMMAND 2
LONG RANGE SENSOR SCAN FOR QUADRANT 6,3
-------------------
| 005 | 007 | 007 |
-------------------
| 004 | 013 | 001 |
-------------------
| 005 | 002 | 016 |
-------------------

The values you see in a long range scan are the only values tracked by the game. It doesn’t store the exact sectors of each entity within a quadrant until you enter it. On a related note, the computer can show you a table of all scanned quadrants (option 7, option 0):

COMMAND 7
COMPUTER ACTIVE AND AWAITING COMMAND 0
COMPUTER RECORD OF GALAXY FOR QUADRANT 6,3
-------------------------------------------------
| 000 | 000 | 000 | 008 | 008 | 004 | 000 | 000 |
-------------------------------------------------
| 000 | 000 | 000 | 006 | 005 | 007 | 007 | 000 |
-------------------------------------------------
| 000 | 000 | 000 | 001 | 004 | 013 | 001 | 000 |
-------------------------------------------------
| 000 | 000 | 000 | 002 | 005 | 002 | 016 | 000 |
-------------------------------------------------
| 000 | 000 | 000 | 000 | 000 | 000 | 000 | 000 |
-------------------------------------------------
| 000 | 000 | 000 | 000 | 000 | 000 | 000 | 000 |
-------------------------------------------------
| 000 | 000 | 000 | 000 | 000 | 000 | 000 | 000 |
-------------------------------------------------
| 000 | 000 | 000 | 000 | 000 | 000 | 000 | 000 |
-------------------------------------------------

Anyway, that’s the gist of the game.

So, what happens when you win?

THE LAST KLIGON BATTLE CRUISER IN THE GALAXY HAS BEEN DESTROYED
THE FEDERATION HAS BEEN SAVED !!!

YOUR EFFICIENCY RATING = ...

And then it just starts over again with a new mission. The efficiency rating is a function of the time remaining. In Mike Mayfield’s original version, the time remaining was actually in minutes. As mentioned, in this version, it’s in turns.

Super Star Trek

In 1976, Creative Computing published a modified version of Mike Mayfield’s program titled Super Star Trek. It’s virtually identical to the original game. However, the menus accept 3 letter mnemonics instead of numbers. The computer offers a few more options. And, just for fun, each quadrant has a name. With those ideas in mind, I decided to code my own version of the game. I began by digging up some ancient ASCII art...

          ______ _______ ______ ______    _______ ______  ______ __  __
         / __  //__  __// __  // __  /   /__  __// __  / / ____// / / /
        / / /_/   / /  / /_/ // /_/ /      / /  / /_/ / / /__  / // /
        _\ \     / /  / __  //   __/      / /  /   __/ / __ / /   /
      / /_/ /   / /  / / / // /\ \       / /  / /\ \  / /___ / /\ \
     /_____/   /_/  /_/ /_//_/  \_\     /_/  /_/  \_\/_____//_/  \_\

                      ________________        _
                      \__(=======/_=_/____.--'-`--.___
                                 \ \   `,--,-.___.----'
                               .--`\\--'../
                              '---._____.|]

Mission: Destroy 20 Klingon ships in 46 stardates with 3 starbases.

Enter command:

--- Commands -----------------
nav = Navigation
srs = Short Range Scan
lrs = Long Range Scan
pha = Phaser Control
tor = Photon Torpedo Control
she = Shield Control
com = Access Computer

Enter command: srs

-=--=--=--=--=--=--=--=-             Region: Altair IV
                                   Quadrant: [2,5]
             *                       Sector: [1,6]
                                   Stardate: 2287
                   *         Time remaining: 46
                                  Condition: GREEN
<*>                                  Energy: 3000
                                    Shields: 0
 *                         Photon Torpedoes: 10
-=--=--=--=--=--=--=--=-             Docked: False

Enter command: lrs

-------------------
| 117 | 118 | 004 |
-------------------
| 006 | 003 | 008 |
-------------------
| 004 | 001 | 115 |
-------------------

Enter command: nav

Enter course (1.0--9.0): 3
Enter warp factor (0.1--8): 1

Warp engines engaged.

-=--=--=--=--=--=--=--=-             Region: Risa
    *           *                  Quadrant: [2,4]
                                     Sector: [1,6]
            +++ *     *            Stardate: 2288
                      *      Time remaining: 45
>!<                               Condition: RED
<*>                *                 Energy: 3000
                                    Shields: 0
             *     *       Photon Torpedoes: 10
-=--=--=--=--=--=--=--=-             Docked: True

Condition RED: Klingon ship detected.

Lowering shields as part of docking sequence...
Enterprise successfully docked with starbase.

Enter command: pha

Phasers locked on target.
Enter phaser energy (1--3000): 500

Firing phasers...
Hit ship at sector [5,3]. Klingon shield strength dropped to 206.

Enterprise hit by ship at sector [5,3]. No damage due to starbase shields.

Enter command: pha

Phasers locked on target.
Enter phaser energy (1--2500): 500

Firing phasers...
Klingon ship destroyed at sector [5,3].

Enter command: srs

-=--=--=--=--=--=--=--=-             Region: Risa
    *           *                  Quadrant: [2,4]
                                     Sector: [1,6]
                *     *            Stardate: 2288
                      *      Time remaining: 45
>!<                               Condition: GREEN
<*>                *                 Energy: 2000
                                    Shields: 0
             *     *       Photon Torpedoes: 10
-=--=--=--=--=--=--=--=-             Docked: True

Enter command:

There are many subtle nuances in the original game. How often do different parts of the Enterprise malfunction? How and when do photon torpedoes randomly deviate from their specified targets? And so on. It doesn’t really matter. As I said above, this is the kind of game that deserves to be reinvented everytime it trades hands. The exact parameters of the Star Trek universe are up to the coder. For example, in my version, different parts of the Enterprise malfunction depending on how often you use them. If you rely on the computer for targeting Klingon ships too much, the computer will start to fail.

Rewriting the game brought up an interesting aspect of the BASIC version. Targeting is done using polar coordinates, but you won’t find any trigonometric functions in the BASIC code. I assume the functions were unavailable. Instead, the angle is converted into a direction vector using different ratios that approximate the trigonometric functions. That means even if you worked out perfect targeting using trigonometry, when you entered in the angle, the actual trajectory will be slightly off. Nonetheless, it’s a pretty clever math trick. As for me, I took advantage of Math.Sin() and Math.Cos().

Finally, if you’re ready to enter the ASCII Star Trek universe and save the Federation from attacking Klingon plus-signs, download the attached source code.

References

License

This article, along with any associated source code and files, is licensed under The GNU Lesser General Public License (LGPLv3)

Share

About the Author

Michael Birken

Unknown
No Biography provided

Comments and Discussions

 
QuestionRandomizer PinmemberBooGhost7-Mar-12 6:44 
AnswerRe: Randomizer PinmemberPeter Hawke16-May-12 15:25 
AnswerRe: Randomizer PinmemberUser819215-Oct-13 12:04 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web01 | 2.8.141015.1 | Last Updated 29 Jul 2008
Article Copyright 2008 by Michael Birken
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid