The Classic Super Star Trek Game

Super Star Trek is quite possibly the best of the "Star Trek" games from the 1970's. Of course, it does not make use of graphics, or even assume a video display, but it still an interesting game to play, particularly for those of us who don't have the reflexes we used to and prefer a more cerebral computer game.

Of course, Star Trek and it's characters are trademarks of Paramount Studios, Inc. And just like the original game, written by Star Trek fans who were also the, back then, rare breed of computer geek, isn't used with permission but with admiration of the show.

This game was written by David Matuszek and Paul Reynolds, with modifications by Don Smith. I've received further information that the black holes, Tholian web, Super Commander, and Emeritus mode were added by Marc Newman. I resurrected the game, rewrote it in C, and fixed many bugs.

In June 2002, I fixed two known bugs and a documentation typo, and created a new Linux version. In June 2004 I fixed a number of bugs involving: 1) parsing invalid numbers, 2) manual phasers when SR scan is damaged and commander is present, 3) time warping into the future, 4) hang when moving klingons in crowded quadrants.

In December 2010, I fixed bugs involving attempting to fire more than 3 torpedoes at once, a typo ("READ ALERT"), and a couple of buffer overflow issues.

In October 2013 I fixed a bug that caused the number of remaining Klingons to be negative when the remaining Klingons and the Enterprise are destroyed in a Super Nova. Typos pointed out by users have been corrected. I added the ability to get the current score (why was that never possible?), and have an optional fix that rotates the scan displays so that the X axis is horizontal. Yes, for some reason the authors of SST had the displays rotated 90 degrees clockwise. Just add -f as the first command line argument. Fixed instance where total casualties would decrease when casualties occur.

In December 2013 I added three new commands -- CLOAK to cloak the Enterprise, CAPTURE to allow Klingons to surrender, and SCORE to show the score in the game. I also fixed many typos in the program dialog and in the documentation.

In June 2015 I fixed some bugs that kept certain counts from being reset when starting a new game. In August I fixed a bug that was reporting a violation of the Treaty of Algeron that did not occur, and the lack of the Score command in the Windows version. In December an extraneous control-S character was deleted from sst.c source file.

In January 2019 I did the following: Numerous reported typos, spelling, and grammar errors corrected. References to "Romulan ship captured" changed to "Romulan ship surrendered" since that is what happens at the end of a won game. "Klingons per stardate" changed to "Klingon ships per stardate".

Death Ray can no longer be repaired with a 0.1 stardate rest at a base.

Damage Report no longer states the Death Ray can be repaired away from a base.

Capturing prisoners while docked will have them immediately transferred to the base rather than going into the ship?s brig.

If the Cloaking Device is damaged in the same turn it is activated, it gets deactivated.

Destroying the remaining enemy ships with the Death Ray should no longer give a negative number of Klingons left.

If the game is compiled without the CLOAK, CAPTURE, and/or SCORE commands, issuing those commands now gives an invalid command message rather than just being silent. These commands are enabled by default.

In February 2019 I corrected a compilation error (I compiled it for "Debug") in the Windows Console version.

  • Super Star Trek For LINUX (77k) -- built for 32-bit Linux. If you have a 64-bit distribution you will need to add 32-bit support or recompile from source.
  • Super Star Trek for Windows Console (98k)
  • Super Star Trek for Mac OS X (85k) -- 64-bit Intel only.
  • Source code (Generic ANSI C, 90k) As is will build on Linux or Mac OS X. Has instructions to build with VisualStudio for Windows.

The DOS version requires a 80386 or better. Since source code is available, Super Star Trek can be compiled for virtually any system having a C compiler and sufficient memory for execution (which isn't much by today's standards!)

History of This Version

I first played Super Star Trek in the mid 1970's. It was a game on the Control Data mainframe computer, and was a big hit at work during evening hours.

About 1977 I got a copy the source code of the game. Someone had converted it to PDP-11 Fortran but couldn't get it to run because of its size. I modified the program to use overlays and managed to shoehorn it in on the 56k byte machine.

I liked the game so much I put some time into fixing bugs, mainly what could be called continuity errors and loopholes in the game's logic. We even played a couple tournaments.

In 1979, I lost access to that PDP-11. I did save the source code listing. In 1995, missing that old friend, I started converting the program into portable ANSI C. It's been slow, tedious work that took over a year to accomplish.

In early 1997, I got the bright idea to look for references to "Super Star Trek" on the World Wide Web. There weren't many hits, but there was one that came up with 1979 Fortran sources! This version had a few additional features that mine didn't have, however mine had some feature it didn't have. So I merged its features that I liked. I also took a peek at the DECUS version (a port, less sources, to the PDP-10), and some other variations.

Modifications I Made

Compared to original version, I've changed the "help" command to "call" and the "terminate" command to "quit" to better match user expectations. The DECUS version apparently made those changes as well as changing "freeze" to "save". However I like "freeze".

I added EMEXIT from the 1979 version.

That later version also mentions srscan and lrscan working when docked (using the starbase's scanners), so I made some changes here to do this (and indicating that fact to the player), and then realized the base would have a subspace radio as well -- doing a Chart when docked updates the star chart, and all radio reports will be heard. The Dock command will also give a report if a base is under attack.

It also had some added logic to spread the initial positioning of bases. That made sense to add because most people abort games with bad base placement.

The experimental deathray originally had only a 5% chance of success, but could be used repeatedly. I guess after a couple years of use, it was less "experimental" because the 1979 version had a 70% success rate. However it was prone to breaking after use. I upgraded the deathray, but kept the original set of failure modes (great humor!).

I put in the Tholian Web code from the 1979 version.

I added code so that Romulans and regular Klingons could move in advanced games. I re-enabled the code which allows enemy ships to ram the Enterprise; it had never worked right. The 1979 version seems to have it all fixed up, but I'm still not overly happy with the algorithm.

The DECUS version had a Deep Space Probe. Looked like a good idea so I implemented it based on its description.

In 2013 I added the CLOAK and CAPTURE commands and also fixed lots of bugs. The CAPTURE command is based on the one in BSDTrek. When making this change I also changed text so that killing Klingons became destroying Klingon ships reflecting that a Klingon ship does have more than one Klingon aboard! The CLOAK command and some other bug fixes and correction of typos are thanks to Erik Olofsen.

I revised the documentation to match the version.

super-star-trek

super-star-trek

  • Download source code zip tar.gz tar.bz2 tar
  • Copy SSH clone URL [email protected]:esr/super-star-trek.git
  • Copy HTTPS clone URL https://gitlab.com/esr/super-star-trek.git
  • Console/Handheld
  • Retro Computers
  • Retro Game Hunter (Directory)
  • Retro Arcade Hunter (Directory)

Old School Gamer Magazine

Super Star Trek – 1970s source code of the 80 column printer terminal based simulation, converted to many 8bit systems!

by Indie Retro News | Jun 13, 2023 | 1980s , 1990s , 2000s , Indie Built-Retro Inspired

super star trek source code

Fancy a new game for the Acorn Electron, BBC Micro, Commodore PET, Commodore 64, Plus/4 or Vic-20, then you’ve come to the right place! As thanks to a heads up by a good friend of ours in our inbox, we’ve learnt of a classic treky game that has been released for all those systems mentioned above called ‘Super Star Trek’. As in the words of electron.greg (as an example for the Commodore 64 version) “I have taken the original 1970s source code of the 80 column printer terminal based simulation and converted it to run on a Commodore 64, No mainframe required!”.

super star trek source code

For those of you with a BBC Micro however, here is what the creator also describes about that version! “Whilst undertaking this conversion I have added numerous subtle enhancements, including “helpers” for navigation & photon torpedo targeting and long range scanner interpretation guide. I’ve re-engineered and refined many stats, charts & data outputs. I’ve also added some user-friendly features and extra summary data readouts. All whilst keeping to the exact gameplay experience of the original. This program is 100% text based and uses ZERO cursor control codes, only carriage returns, just like the mainframe terminal-based games of the 70s”.

Links :1) Source  Thanks Liqmatrix for this awesome heads up!

Indie Retro News

Indie Retro News is a cool independent publisher that we found in our own surfing of cool retro gaming sites. They have given us permission to publish their articles on our site after they hit theirs first. Check out more on Indie Retro News at http://www.indieretronews.com

Share this:

  • Click to share on Twitter (Opens in new window)
  • Click to share on Facebook (Opens in new window)

Username or Email Address

Remember Me

Join Now | Lost Password?

Latest Magazine For Paid Subscribers

To Read Click Cover

Latest Magazine For Free Subscribers

Subscribe Here

Sign up for Free OSG

super star trek source code

Super Star Trek

Access full-text files, journal title, journal issn, volume title, description, lcsh subject headings, collections.

The classic book BASIC Computer Games , published by Creative Computing , inspired a generation of programmers. The games were written by many people, and compiled by David H. Ahl . The fabulous illustrations accompanying each game were done by George Beker .

I've included all the games here for your tinkering pleasure. I've tested and tweaked each one of them to make sure they'll run with Vintage BASIC, though you may see a few oddities. That's part of the fun of playing with BASIC: it never works quite the same on two machines. The games will play better if you keep CAPS LOCK on, as they were designed to be used with capital-letter input.

The table below includes both links to the pages of the book at atariarchives.org , and the source code for each game. I obtained most of the source code from classicbasicgames.org , with the exception of Civil War and Super Star Trek, which I entered myself. The descriptions mainly come from an earlier edition of the book, 101 BASIC Computer Games , via the scans at digibarn.com . All book content is provided with the express consent of David H. Ahl, editor.

You can download the entire set of games as a tarball ( bcg.tar.gz ) or a ZIP archive ( bcg.zip ).

super star trek source code

50 Years of Text Games

super star trek source code

1974: Super Star Trek

super star trek source code

Update: Find out more about the 50 Years of Text Games book and the revised final version of this article!

Super Star Trek by Mike Mayfield and Bob Leedom Released: Unpublished original (1971); STTR1 (published by HP 1973); SPACWR (EDU, 1973); Leedom version (1974); Super Star Trek (Creative Computing, 1975) Language: BASIC Platform: SDS Sigma 7 Opening Text: ,------*------, ,------------- ‘--- ------’ ‘-------- --’ / / ,---‘ ’-------/ /--, ‘----------------’ THE USS ENTERPRISE --- NCC-1701 YOUR ORDERS ARE AS FOLLOWS: DESTROY THE 10 KLINGON WARSHIPS WHICH HAVE INVADED THE GALAXY BEFORE THEY CAN ATTACK FEDERATION HEADQUARTERS ON STARDATE 2025 THIS GIVES YOU 25 DAYS. THERE ARE 4 STARBASES IN THE GALAXY FOR RESUPPLYING YOUR SHIP

The final episode of Star Trek aired on June the 3rd, 1969, just as superfan Mike Mayfield was finishing his sophomore year of high school. It was called “Turnabout Intruder” and it was not a very good episode . Trek had been saved from cancellation once before through a devoted letter-writing campaign, but this time it had proved harder to rally the troops. The show’s third season had been on the whole less inspired, and it seemed now to be going out with a whimper. A rerun of The Mod Squad scored twice as many viewers that night. It would be more than a decade before any new live-action Trek would appear. In the meantime, the fans would have to keep the flame burning themselves.

Mayfield, like other tech-minded Trekkies, saw in the increasing power of minicomputers a way to keep the show’s spirit alive. Trek games with varying levels of complexity had appeared on mainframe systems in the late ’60s and early ’70s, copied, re-shared, and improved ad-hoc like most other early programs. Today it’s hard to piece together the genealogy of these dozens of early games, in part because attribution and even self-attribution were rare, but also because so many of them were entitled simply Star Trek . While it proved difficult to capture the big ideas of episodes like “The City on the Edge of Forever” in a game, easier to simulate were the tactics and strategy of ship-to-ship combat, as in season one fan-favorite “Balance of Terror” where Kirk plays a cat-and-mouse game with a Romulan commander. Trek also provided a ready-to-hand frame story for a game in a time when there was little storage space or inclination to create one from scratch. But all this was academic for Mayfield, quite literally: computers were still precious resources locked away in university labs, and the 16-year-old had no way to access one.

Not long after the TV series had ended, Mayfield saw a demonstration on the UC Irvine campus near his school of SpaceWar! (probably the other most influential early space combat game). SpaceWar! used a cutting-edge CRT monitor to draw tiny vector-graphic spaceships that players could maneuver around a mostly-empty screen, firing torpedoes at each other and trying to avoid the gravitational pull of a central star. It was fun, it was addictive, and it seemed like the future: most computing was still done via teletype printer, so a dynamically-updating screen was a revelation. Mayfield’s mind was duly blown by the experience, and he began to yearn desperately for computer access of his own. He knew connecting to a distant computer via teletypewriter was within the realm of possibility—other schools across the country had started to do it, just not his—but at first he could only daydream :

“A bunch of my other geek friends from high school and I spent a lot of hours brainstorming what we could do if we didn’t have a video terminal. Since I was the only one in the group that had any knowledge of computers (little as it was), we ended up coming up with a lot of unimplementable ideas. One idea that did stick was the idea of printing a galactic map and a star map to give you some idea what to shoot at.”

Eventually, Mayfield arranged for remote access to the Sigma 7 at UC Irvine by borrowing an enrolled student’s account (something which was not, strictly speaking, allowed). He slowly taught himself BASIC from a textbook, typing in lines one at a time on the teletypewriter. His account had no access to permanent storage space, so each time he worked on a program he’d have to output it on punch tape after finishing for the day, and carefully load it back in the next time he wanted to make any edits. Progress was slow. But by the end of the summer after his senior year in 1971, he’d managed to make himself a Trek game that struck a surprisingly mature balance between playability and complexity.

Originally bearing no title other than just STAR TREK , Mayfield’s game puts you in command of the Enterprise and tasks you with hunting down Klingons spread throughout the galaxy. The terrain is divided into an 8x8 grid of 64 quadrants, each of which in turn encloses a square of 64 sectors, resulting in a map with about four thousand possible positions. Each quadrant has a handful of stars, which serve as cover for Klingons and obstacles for navigation. Some quadrants have a starbase where the Enterprise can restock photon torpedoes and recover the energy expended to power her warp drive and shields. The goal is to find the Klingons and defeat them all within thirty stardates. In the map, a * marks a star and <*> is your ship.

[Note: all transcripts are from the 1974 Mayfield/Leedom version of the game discussed further below. Mayfield's original looks similar but with slightly different formatting and some terser messages. I have removed some horizontal whitespace to try to minimize word-wrapping.]

The map, printed out along with all other text on the user’s teletype, was an early example of what would later be called ASCII graphics: positioning characters of text to create primitive visuals. Years later, the genre of roguelikes would turn this into a well-recognized aesthetic. But more fundamentally, the design of Mayfield’s game provided more emergence and room for strategy than most contemporary titles. Eight different commands let you control the engines, shields, phasers, photon torpedoes, short- and long-range scanners, damage control, and a library computer. Most commands take additional parameters: how much energy to transfer to shields, which computer commands to access, or what speed and direction to feed into the warp drive (using a numbered cardinal rose printed in the instructions). Fractional values are allowed, letting players fine-tune movement in or between quadrants: with enough precision, you can warp halfway across the galaxy and arrive in the perfect position for an attack. The combinatorial space of commands feels refreshingly larger than in earlier games like ROCKET (1972) or Hunt the Wumpus (1973), and the grid of terrain which must be explored and scanned to hunt down the enemy creates a sense of danger and discovery. Ship systems can be damaged through taking enemy fire or overusing the warp engines, and each kind of damage offers different trade-offs for deciding whether to continue to hunt baddies or lose time finding a starbase for repairs.

Most plans in the game require a sequence of steps to execute, enhancing the illusion of commanding a complex starship and not just an asterisk. Finding the scattered Klingons, for instance, means deploying your library computer and both types of scanners. Long-range scans show the quadrants surrounding your present location with a three-digit code which you must learn to decipher: 114 would signify a quadrant with one Klingon, one starbase, and four stars. When you warp to a quadrant with an enemy, after diverting some energy to your shields you might need to decide between using phasers or torpedoes, each with different strategic considerations. You can spend an amount of energy of your choosing on a phaser shot, which can hit multiple enemies regardless of positioning: but the damage varies based on distance, randomness, and the strength of the enemy’s shields. Torpedoes, however, always destroy a single enemy, but you need line of sight to use them, which means you might need to maneuver around a star and open yourself up to counterattacks in the process. You must also calculate the proper trajectory to fire a torpedo, or learn how to use the library computer to calculate it for you and then manually input its suggested parameters. Playing Mayfield’s Trek required paying attention. It suggested a level of seriousness and attention to detail that had rarely been seen in earlier computer games.

The game’s code has to use a number of clever hacks to get around the severe limitations of early BASIC. Its 4,096 grid locations would have surpassed the memory limits of many systems of the time, so rather than storing the randomly generated contents of each galactic quadrant in a 2D array, this data is lossily “compressed” into the same three-digit numeric code revealed by the long-range scanners. When a sector is entered, the appropriate number of stars and Klingons are distributed onto the sector map at random. This sleight-of-hand works in large part because you rarely have cause to re-enter the same quadrant twice. If you do, it’s usually because you had to flee from an enemy, and it makes sense for them to be in a different position once you return. Most players would be unlikely to notice that the stars had moved, too.

At the same time, the code is filled with hints betraying its “learn as you go” origins, with various features of HP2000C BASIC used once or twice as if to try them out, then abandoned. The program defines exactly one function (a relatively new concept in BASIC at the time) and only uses it twice, instead relying on traditional GOSUB/RETURN blocks for the bulk of its reusable code. An 8x8 array stores the 3-digit quadrant signature, but the current quadrant’s contents are tracked with a much hackier method possibly written earlier. It works by rendering the current quadrant’s map image into three strings Q$, R$, and S$: because of a 72-character limit for string variables, three of them are needed to store the contents of a grid containing 64 areas each three characters wide. Checking positions or updating the map happens through laboriously calculating which set of three characters in which string correspond to the X,Y coordinates in question. Here’s the code (circa 1973) to update the sector at Z1, Z2 with the map symbol stored in A$, picking through each of those partial map arrays Q$, R$, and S$ to find the one with the 3-character block it’s looking for:

The code is representative of the challenges of writing complex programs in early ‘70s BASIC, with variable names limited to a single letter and optional number, no distinction between global and local variables, and no way to give code blocks meaningful names. While BASIC was a big step up from earlier languages, working out what an unfamiliar program did was often still a difficult chore. And yet this was part of the fun for early hackers, who loved to sit down with a listing for an interesting program and figure out, line by line, how it worked.

As Mayfield’s Trek passed through various hands during the early 1970s, it was updated to new versions of BASIC or enhanced with extra features. The most well-known revision was by Bob Leedom, a professional coder at Westinghouse working on their Data General Nova line of minicomputers. Leedom worked on and off throughout 1974 on an updated Trek that left most of Mayfield’s core systems and gameplay intact, but added a few nice touches that gave the game more polish and dynamism. His version replaced the original’s numeric commands with three-letter codes (like LRS for long-range scan, or NAV to engage the engines) reminiscent of the cryptic buttons from the onboard computer system the Apollo astronauts had used. He added better instructions and punched up the in-game messages: Mayfield’s text for a torpedo intersecting a star—“YOU CAN’T DESTROY STARS SILLY”—was replaced with the somewhat more mature and immersive “STAR AT 7,3 ABSORBED TORPEDO ENERGY.” Blowing up a starbase in the original simply removes it from the map; in Leedom’s version it results in Starfleet considering a court-martial. Memorably, many status reports and error messages were rewritten as if the show’s famous bridge crew were relaying them. Trying to warp off the edge of the map in Leedom’s version results in:

Leedom also gave the game’s numbered quadrants evocative names like RIGEL IV, gave the library computer additional helpful functions, and made Klingons move to a random position after being fired on (rather than waiting around like sitting ducks for you to line up a torpedo shot). These tweaks went a long way to increasing the fun factor of Mayfield’s original, while preserving its successful core gameplay.

Leedom’s improved program was published by David H. Ahl in “Creative Computing” magazine under the name Super Star Trek to differentiate it from earlier versions, and later appeared in the million-selling book BASIC Computer Games , cementing its place as the best-known Trek game of the decade. Countless other spin-offs and improvements continued to proliferate, rarely crediting the original authors. A two-player version called WAR evolved into the multi-player DECWAR and later the popular MegaWars strategy game series on CompuServe. A version called Apple Trek came out for the Apple II; Radio Shack released one called Space Trek for the Tandy. A more involved enhancement that added 3D combat against a moving starfield appeared for the Atari in 1979’s Star Raiders . Widely recognized as one of the platform’s breakout titles, it would directly inspire later games like Elite and Wing Commander that defined space combat sims for a generation. Paramount’s own officially licensed Trek games, once it got around to releasing some, would never have a remotely equivalent impact.

Super Star Trek was not the most literary nor the most complex Trek game of the decade. A 1973 version by William K. Char, for instance, featured extensive dialogue from the bridge crew and dozens of commands to do things like jettison the warp core or try obscure strategies from the original show like Kirk’s Corbomite Maneuver. There were plenty of other Treks floating around at all levels of complexity, many of which have since been lost to bit rot or neglect. But Mayfield and Leedom’s program settled into its role as the standard in part by occupying a useful middle ground: it was complex enough to be interesting, but short enough to be printed in a magazine or book, in an era when that was still the best way to widely disseminate software. As the longest program in BASIC Computer Games (at about 500 lines of code without the instructions), it required a smaller font than other listings, bordering on illegibility. But it fit. Had it been much longer, it might have been deemed too difficult to include, and never reached a wider audience.

It would be neither the first nor last time that technical limitations restricted the upper bounds of a text game’s complexity, but Super Star Trek provided one of the final examples of a case where those limits—page counts and print size—would have been understandable to a creator from an earlier century. Games were soon to boldly go where no book printer had gone before.

Next week : how a rowdy band of dungeon crawlers took over a groundbreaking computer network that was supposed to be used purely for education.

Get the 50 Years of Text Games book!

You can play a 1980 Commodore 64 port of Super Star Trek online; it has some major differences from the original, like sounds and color, but is the closest version I can find playable online. You might instead try running the BASIC source code yourself in Vintage BASIC . A detailed history of the game’s evolution by Maury Markowitz is accessible thanks to the Internet Archive. I also did a much messier source code dive last year if you’re into that sort of thing.

50 Years of Text Games logo

Ready for more?

super star trek source code

  • Latest Articles
  • Top Articles
  • Posting/Update Guidelines
  • Article Help Forum

super star trek source code

  • View Unanswered Questions
  • View All Questions
  • View C# questions
  • View C++ questions
  • View Javascript questions
  • View PHP questions
  • View Python questions
  • CodeProject.AI Server
  • All Message Boards...
  • Running a Business
  • Sales / Marketing
  • Collaboration / Beta Testing
  • Work Issues
  • Design and Architecture
  • Artificial Intelligence
  • Internet of Things
  • ATL / WTL / STL
  • Managed C++/CLI
  • Objective-C and Swift
  • System Admin
  • Hosting and Servers
  • Linux Programming
  • .NET (Core and Framework)
  • Visual Basic
  • Web Development
  • Site Bugs / Suggestions
  • Spam and Abuse Watch
  • Competitions
  • The Insider Newsletter
  • The Daily Build Newsletter
  • Newsletter archive
  • CodeProject Stuff
  • Most Valuable Professionals
  • The Lounge  
  • The CodeProject Blog
  • Where I Am: Member Photos
  • The Insider News
  • The Weird & The Wonderful
  • What is 'CodeProject'?
  • General FAQ
  • Ask a Question
  • Bugs and Suggestions

super star trek source code

Star Trek 1971 Text Game

super star trek source code

  • Download source - 41.11 KB

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 on 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:

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:

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 7 th 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:

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:

These are not executable statements. They’re string s 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:

And the C# version:

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:

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:

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):

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):

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):

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:

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:

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):

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):

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):

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):

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

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

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

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:

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

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

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:

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.

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):

Anyway, that’s the gist of the game.

So, what happens when you win?

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

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.

  • Star Trek Game History: http://www3.sympatico.ca/maury/games/space/star_trek.html
  • Wiki: http://en.wikipedia.org/wiki/Star_Trek_%28text_game%29
  • Mike Mayfield’s Original Code: http://www.dunnington.u-net.com/public/startrek/STTR1
  • Enhanced Version: http://newton.freehostia.com/hp/bas/TREKPT.txt
  • Super Star Trek: http://www.atariarchives.org/bcc1/showpage.php?page=275

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

Comments and Discussions

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

  • Random Programming Competition, Summer 2008
  • Best C# article of July 2008

super star trek source code

  • View all by electron.greg Creator
  • Add To Collection Collection
  • Related games Related

Super Star Trek (VIC-20)

A downloadable game

I have taken the original 1970s source code of the 80 column printer terminal based simulation and converted it to run on a 22 column Commodore VIC-20 (32-35k) ...No mainframe required!

Whilst undertaking this conversion I have added numerous subtle enhancements, including "helpers" for navigation & photon torpedo targeting and long range scanner interpretation guide. I've re-engineered and refined many stats, charts & data outputs. I've also added some user-friendly features and extra summary data readouts. All whilst keeping to the exact gameplay experience of the original.

This program is 100% text based and uses ZERO cursor control codes, only carriage returns, just like the mainframe terminal-based games of the 70s.

Converting an 80 column program to run on 22 column computer was VERY difficult. There may be bugs and/or formatting issues. Please let me know.

Install instructions

Commodore VIC-20 : Download the disc image file " trek-vic20.d64 "    V2.7b

Once the disc image is on your Commodore, in most cases, the commands to type are:

LOAD "TREK",8,1  [RETURN] 

(or " TREK-M " for the monochrome version)

RUN  [RETURN]

Development log

  • December 2023 update 87 days ago

Log in with itch.io to leave a comment.

I now have a real VIC-20 machine. It is very tired (electronically speaking) and the video output is rough. It's apparently very common on VICs. So, I will be adding a totally monochrome version of the game in the disk image file. I've already tested it and it's MUCH much clearer this way. Uploading very soon.

Well, this is just awesome.  In theory, do you think the program would fit on a 5 1/4" and play on a 32k expanded Vic?

Thank you! Yes, indeed you could.

Most screenshots are from previous version. There are slight improvements with latest update (v2.7).

super star trek source code

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

Here are 11 public repositories matching this topic...

Themanyone / whisper_dictation.

Fast! Offline, privacy-focused, hands-free voice typing, 2-way AI voice chat, with images, voice control, in under 4 GiB of VRAM.

  • Updated Feb 29, 2024

discully / afinalunity

Extract files from Star Trek TNG: A Final Unity.

  • Updated Dec 20, 2023

jp00p / AGIMUS

Discord bot for Friends of Desoto

  • Updated Mar 4, 2024

Python3-Training / PyTrek

A Python port of the classic Star Trek BASIC game from 1971. Updated to Python 3.

  • Updated Nov 27, 2023

thescribe11 / Super-Star-Trek

This is my Python port of Super Star Trek, which is one of the oldest PC games.

  • Updated Sep 8, 2021

ggolish / TriD

An implementation of tridimensional chess from Star Trek

  • Updated Dec 14, 2018

onyame / ncc1701

Getting python ready for the enterprise

  • Updated Mar 16, 2015

pschillo / next-gen-generator

I pitched this as a project "involving machine-generated speech, star trek and, quite possibly, a telegram bot". That is a good place to start.

  • Updated Jul 6, 2021

gnramsay / trekpedia

WIP: Star Trek TV/Film episode database in JSON format, scraped from web sources (primarily Wikipedia)

  • Updated Feb 19, 2024

fechan / RomuRabble-tools

Tools for the RomuRabble projects, which analyses Romulan language (PIC-era)

  • Updated Oct 8, 2020

xyz666 / trek-game

Python 3 port of a Tiny Basic 'trek' game with improvements

  • Updated Mar 5, 2018

Improve this page

Add a description, image, and links to the star-trek topic page so that developers can more easily learn about it.

Curate this topic

Add this topic to your repo

To associate your repository with the star-trek topic, visit your repo's landing page and select "manage topics."

IMAGES

  1. GitHub

    super star trek source code

  2. GitHub

    super star trek source code

  3. GitHub

    super star trek source code

  4. GitHub

    super star trek source code

  5. GitHub

    super star trek source code

  6. GitHub

    super star trek source code

VIDEO

  1. Star Trek: Shattered Universe Walkthrough Mission 6: Field of Honor (Cheat)

  2. 10 Greatest Star Trek Cold Opens

  3. Star Trek TNG S1 EP 3 Code of Honor Reviewed Trek's Most Problematic Show?

  4. Let's Watch

  5. The shocking truth about Star Trek Discovery season 5

  6. Star Trek: Resurgence| GTX 1650S 4GB + i5 3470

COMMENTS

  1. Super Star Trek

    Super Star Trek is probably the most famous early text-only game ever created - or at least as famous as The Oregon Trail or Zork - and it inspired many other videogames. Since the code was public domain, during the years, it was changed and improved many times.

  2. Code Archaeology with " Super Star Trek"

    Code Archaeology with ". Super Star Trek". One of the most interesting things about BASIC programs is their line numbers. Often decried by younger coders as enablers of the dreaded GOTO, they ...

  3. The Classic Super Star Trek Game

    If you have a 64-bit distribution you will need to add 32-bit support or recompile from source. Super Star Trek for Windows Console (98k) Super Star Trek for Mac OS X (85k)-- 64-bit Intel only. Source code (Generic ANSI C, 90k) As is will build on Linux or Mac OS X. Has instructions to build with VisualStudio for Windows.

  4. Eric S. Raymond / super-star-trek · GitLab

    Super Star Trek is almost the oldest of all heritage computer games, originating in 1973 on the CDC6600. This port has been prepared with the assistance of the lead author of the original FORTRAN. ... February 18, 2017. Find file Select Archive Format. Download source code. zip. tar.gz. tar.bz2. tar. Copy HTTPS clone URL Copy SSH clone URL git ...

  5. GitHub

    Starship U.S.S. Enterprise, your job is to wipe out the Klingon. invasion fleet and make the galaxy safe for democracy. Your battleground is the entire galaxy, which for convenience is. divided up into eight rows of eight quadrants each, like a. checkerboard. Rows are numbered from top to bottom, and columns are.

  6. The Classic Super Star Trek Game (1970's-1980's)

    In early 2013, I stumbled over the old 1991 source code for TREK, and decided to recompile it using QB64 without any functional modification to run under modern 32-bit and 64-bit versions of Windows. That recompiled version is a 32-bit application called TREK32 (or 64-bit TREK32M for macOS) which really just reflects the compiler target ...

  7. Super Star Trek

    Super Star Trek - 1970s source code of the 80 column printer terminal based simulation, converted to many 8bit systems! by Indie Retro News ... we've learnt of a classic treky game that has been released for all those systems mentioned above called 'Super Star Trek'. As in the words of electron.greg (as an example for the Commodore 64 ...

  8. Super Star Trek

    Description. This is a digital copy of the only known physical print out of the Super Star Trek source code and user manual. This version of the game was created at the University of Texas in 1973/1974 by Dave Matuszek, Richard Cohen, and Paul Reynolds, and updated with additional features in 1976/1977 by Marc Newman.

  9. The Object-Oriented Text Star Trek Game in C++

    The Object-Oriented Text Star Trek Game in C++. James Curran. Rate me: 4.74/5 (10 votes) 6 Aug 2008 CPOL 6 min read 42.2K 815 34 3. The Classic Super Star Trek Game rewritten in modern Object-oriented C++. Download source files (with executable) - 179.15 KB. Shrink .

  10. Vintage BASIC

    I obtained most of the source code from classicbasicgames.org, with the exception of Civil War and Super Star Trek, which I entered myself. The descriptions mainly come from an earlier edition of the book, 101 BASIC Computer Games, via the scans at digibarn.com. All book content is provided with the express consent of David H. Ahl, editor.

  11. 1974: Super Star Trek

    Super Star Trek was not the most literary nor the most complex Trek game of the decade. A 1973 version by William K. Char, for instance, featured extensive dialogue from the bridge crew and dozens of commands to do things like jettison the warp core or try obscure strategies from the original show like Kirk's Corbomite Maneuver.

  12. Star Trek (1971 video game)

    Star Trek is a text-based strategy video game based on the Star Trek television series (1966-69) and originally released in 1971. In the game, the player commands the USS Enterprise on a mission to hunt down and destroy an invading fleet of Klingon warships. The player travels through the 64 quadrants of the galaxy to attack enemy ships with phasers and photon torpedoes in turn-based battles ...

  13. GitHub

    Domain events extends the Event class and represent events that happen in the game such as a Klingon firing or the Enterprise consuming energy. Presenters register listeners and broadcast events with the EventBus.An event-based design has the benefit of decoupling events from actions, so that the component which generates an event isn't concerned with who reacts to it.

  14. Super Star Trek

    Super Star Trek - 1970s source code of the 80 column printer terminal based simulation, converted to many 8bit systems! Fancy a new game for the Acorn Electron, BBC Micro, Commodore PET, Commodore 64, Plus/4 or Vic-20, then you've come to the right place! As thanks to a heads up by a good friend of ours in our inbox, we've learnt of a classic ...

  15. The Javascript Super Star Trek Open Source Project on Open Hub

    This is a Javascript port of the classic 1970s Super Star Trek game, one of a number of (mostly) related trek-themed games from that era. Step into the flared trousers of James T Kirk and command the Enterprise across a galaxy of 8x8 quadrants to repel an invasion of evil Klingon battlecruisers. This version is specifically a direct port of ...

  16. Star Trek 1971 Text Game

    Download source - 41.11 KB; 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.

  17. DarkKnight2019/Super-Star-Trek-1

    Super Star Trek is probably the most famous early text-only game ever created - or at least as famous as The Oregon Trail or Zork - and it inspired many other videogames. Since the code was public domain, during the years, it was changed and improved many times.

  18. Super Star Trek (Amstrad CPC) by electron.greg

    Super Star Trek (Amstrad CPC) A downloadable game. Download. ... This program is 100% text based and uses ZERO cursor control codes, only carriage returns, just like the mainframe terminal-based games of the 70s. ... LOAD "TREK" [return] Development log. December 2023 update.

  19. GitHub

    It has been diffed against the version that appeared on the Vintage-BASIC website and compared against a physical copy of the book. All typos have been reproduced them faithfully from the source. Super Star Trek source —this is the most accurate one I have. Super Star Trek source, annotated —with notes written in exploring the source.

  20. Indie Retro News: Super Star Trek

    Super Star Trek - 1970s source code of the 80 column printer terminal based simulation, converted to many 8bit systems! Fancy a new game for the Acorn Electron, BBC Micro, Commodore PET, Commodore 64, Plus/4 or Vic-20, then you've come to the right place! As thanks to a heads up by a good friend of ours in our inbox, we've learnt of a classic ...

  21. Super Star Trek (VIC-20) by electron.greg

    Super Star Trek (VIC-20) I have taken the original 1970s source code of the 80 column printer terminal based simulation and converted it to run on a 22 column Commodore VIC-20 (32-35k) ...No mainframe required! Whilst undertaking this conversion I have added numerous subtle enhancements, including "helpers" for navigation & photon torpedo ...

  22. star-trek · GitHub Topics · GitHub

    Search code, repositories, users, issues, pull requests... Search Clear. ... Perl and LUA ports of the 1978 Super Star Trek by Bob Leedom. basic lua perl retrogaming star-trek 1970s Updated Jun 14, 2021 ... To associate your repository with the star-trek topic, visit your repo's landing page and select "manage topics." ...

  23. star-trek · GitHub Topics · GitHub

    Search code, repositories, users, issues, pull requests... Search Clear. ... A Python port of the classic Star Trek BASIC game from 1971. Updated to Python 3. ... Code Issues Pull requests This is my Python port of Super Star Trek, which is one of the oldest PC games. game python star-trek Updated Sep 8, 2021; Python; ggolish / TriD Star 3.