# Technical Documentation: coding-horror/basic-computer-games > ℹ️ **Provenance:** Multi-Tier Ingestion · [CodeWiki Reference](https://codewiki.google/github.com/coding-horror/basic-computer-games) ### Overview (`README.md`) ### What are we doing? We’re updating the first million selling computer book, [BASIC Computer Games](https://en.wikipedia.org/wiki/BASIC_Computer_Games), for 2022 and beyond! - [Read the original book](https://archive.org/details/basiccomputergam0000unse) (pdf) - [Play the original games in your browser](https://troypress.com/wp-content/uploads/user/js-basic/index.html) ### Where can we discuss it? Please see [the discussion here](https://discourse.codinghorror.com/t/-/7927) for a worklog and conversation around this project. ### Project structure I have moved all [the original BASIC source code](http://www.vintage-basic.net/games.html) into a folder for each project in the original book (first volume). Note that Lyle Kopnicky has generously normalized all the code (thanks Lyle!) to run against [Vintage Basic](http://www.vintage-basic.net/download.html) circa 2009: > 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. Each project has subfolders corresponding to the languages we’d like to see the games ported to. This is based on the [2022 TIOBE index of top languages](https://www.tiobe.com/tiobe-index/) that are _**memory safe**_ and _**general purpose scripting languages**_ per [this post](https://discourse.codinghorror.com/t/-/7927/34): 1. C# 2. Java 3. JavaScript 4. Kotlin 5. Lua 6. Perl 7. Python 8. Ruby 9. Rust 10. VB.NET > 📢 Note that in March 2022 we removed Pascal / Object Pascal and replaced it with Rust as we couldn’t determine if Pascal is effectively memory safe. We’ve also added Lua, as it made the top 20 in TIOBE (as of 2022) and it is both memory safe and a scripting language. The Pascal ports were moved to the alternate languages folder. > ⚠️ Please note that we have decided, as a project, that we **do not want any IDE-specific or build-specific files in the repository.** Please refrain from committing any files to the repository that only exist to work with a specific IDE or a specific build system. ### Alternate Languages If you wish to port one of the programs to a language not in our list – that is, a language which is either not memory safe, or not a general purpose scripting language, you can do so via the `00_Alternate_Languages` folder. Place your port in the appropriate game subfolder, in a subfolder named for the language. Please note that these ports are appreciated, but they will not count toward the donation total at the end of the project. ### Project goals Feel free to begin converting these classic games into the above list of modern, memory safe languages. In fact, courtesy of @mojoaxel, you can even view the JavaScript versions in your web browser at https://coding-horror.github.io/basic-computer-games/ But first, a few guidelines: - **These are very old games**. They date from the mid-70s so they’re not exactly examples of what kids (or anyone, really?) would be playing these days. Consider them more like classic programming exercises to teach programming. We’re paying it forward by converting them into modern languages, so the next generation can learn from the programs in this classic book – and compare implementations across common modern languages. - **Stay true to the original program**. These are mostly unsophisticated, simple command line / console games, so we should strive to replicate the command line / console output and behavior illustrated in the original book. See the README in the project folder for links to the original scanned source input and output. Try [running the game in your browser](https://troypress.com/wp-content/uploads/user/js-basic/index.html). Avoid the impulse to add features; keep it simple, _except_ for modern conventions, see next item 👇 - **Please DO update for modern coding conventions**. Support uppercase and lowercase. Use structured programming. Use subroutines. Try to be an example of good, modern coding practices! - **Use lots of comments to explain what is going on**. Comment liberally! If there were clever tricks in the original code, decompose those tricks into simpler (even if more verbose) code, and use comments to explain what’s happening and why. If there is something particularly tricky about a program, edit the **Porting Notes** section of the `readme.md` to let everyone know. Those `GOTO`s can be very pesky.. - **Please don’t get _too_ fancy**. Definitely use the most recent versions and features of the target language, but also try to keep the code samples simple and explainable – the goal is to teach programming in the target language, not necessarily demonstrate the cleverest one-line tricks, or big system "enterprise" coding techniques designed for thousands of lines of code. - **Please don't check in any build specific or IDE specific files**. We want the repository to be simple and clean, so we have ruled out including any IDE or build system specific files from the repository. Git related files are OK, as we are using Git and this is GitHub. 😉 ### Emulation and Bugfixes We want the general behavior of the original programs to be preserved, _however_, we also want to update them, specifically: - allow both UPPERCASE and lowercase input and display - incorporate any bugfixes to the original programs; see the `readme.md` in the game folder - improved error handling for bad or erroneous input Please note that on the back of the Basic Computer Games book it says **Microsoft 8K Basic, Rev 4.0 was the version David Ahl used to test**, so that is the level of compatibility we are looking for.  QBasic on the DOS emulation is a later version of Basic but one that retains downwards compatibility so far in our testing. To verify behavior, try [running the programs in your browser](https://troypress.com/wp-content/uploads/user/js-basic/index.html) with [JS BASIC, effectively Applesoft BASIC](https://github.com/inexorabletash/jsbasic/). ### Have fun! Thank you for taking part in this project to update a classic programming book – one of the most influential programming books in computing history – for 2022 and beyond! NOTE: per [the official blog post announcement](https://blog.codinghorror.com/updating-the-single-most-influential-book-of-the-basic-era/), I will be **donating $5 for each contributed program in the 10 agreed upon languages to [Girls Who Code](https://girlswhocode.com/)**. ### Current Progress
toggle for game by language table | Name | csharp | java | javascript | kotlin | lua | perl | python | ruby | rust | vbnet | | ---------------------- | ------ | ---- | ---------- | ------ | --- | ---- | ------ | ---- | ---- | ----- | | 01_Acey_Ducey | x | x | x | x | x | x | x | x | x | x | | 02_Amazing | x | x | x | | | x | x | x | x | x | | 03_Animal | x | x | x | x | x | x | x | x | x | x | | 04_Awari | x | x | x | | | x | x | x | x | x | | 05_Bagels | x | x | x | x | x | x | x | x | x | x | | 06_Banner | x | x | x | | | x | x | x | x | x | | 07_Basketball | x | x | x | | | x | x | x | | x | | 08_Batnum | x | x | x | | | x | x | x | x | x | | 09_Battle | x | x | x | | | | x | | x | x | | 10_Blackjack | x | x | x | | | | x | x | x | x | | 11_Bombardment | x | x | x | | | x | x | x | x | x | | 12_Bombs_Away | x | x | x | | x | x | x | | x | x | | 13_Bounce | x | x | x | | | x | x | x | x | x | | 14_Bowling | x | x | x | | | x | x | | | x | | 15_Boxing | x | x | x | | | x | x | | | x | | 16_Bug | x | x | x | | | | x | x | | x | | 17_Bullfight | x | x | x | x | | | x | | | x | | 18_Bullseye | x | x | x | | | x | x | | x | x | | 19_Bunny | x | x | x | | | x | x | x | x | x | | 20_Buzzword | x | x | x | | x | x | x | x | x | x | | 21_Calendar | x | x | x | | | x | x | x | x | x | | 22_Change | x | x | x | | | x | x | | x | x | | 23_Checkers | x | | x | | | x | x | x | | x | | 24_Chemist | x | x | x | | | x | x | | x | x | | 25_Chief | x | x | x | | x | x | x | x | x | x | | 26_Chomp | x | x | x | | | x | x | | | x | | 27_Civil_War | x | x | x | | | | x | | | x | | 28_Combat | x | x | x | | | x | x | | | x | | 29_Craps | x | x | x | | x | x | x | x | x | x | | 30_Cube | x | x | x | | | | x | x | x | x | | 31_Depth_Charge | x | x | x | | | x | x | x | x | x | | 32_Diamond | x | x | x | x | | x | x | x | x | x | | 33_Dice | x | x | x | | x | x | x | x | x | x | | 34_Digits | x | x | x | | | x | x | | | x | | 35_Even_Wins | x | | x | | | x | x | | x | x | | 36_Flip_Flop | x | x | x | | | x | x | x | x | x | | 37_Football | x | | x | | | | x | | | x | | 38_Fur_Trader | x | x | x | | | x | x | | | x | | 39_Golf | x | | x | | | | x | | | x | | 40_Gomoko | x | x | x | | | x | x | | | x | | 41_Guess | x | x | x | | | x | x | x | x | x | | 42_Gunner | x | x | x | | | x | x | | | x | | 43_Hammurabi | x | x | x | | | | x | | x | x | | 44_Hangman | x | x | x | | | x | x | x | | x | | 45_Hello | x | x | x | | x | x | x | x | x | x | | 46_Hexapawn | x | | | | | | x | | | x | | 47_Hi-Lo | x | | x | x | x | x | x | x | x | x | | 48_High_IQ | x | x | x | | | | x | | | x | | 49_Hockey | x | | x | | | | x | | | x | | 50_Horserace | x | x | x | | | | | | x | x | | 51_Hurkle | x | x | x | | | x | x | x | x | x | | 52_Kinema | x | x | x | | | x | x | x | x | x | | 53_King | x | | x | | | | x | | x | x | | 54_Letter | x | x | x | | | x | x | x | x | x | | 55_Life | x | x | x | | | x | x | x | x | x | | 56_Life_for_Two | x | x | x | | | x | x | | | x | | 57_Literature_Quiz | x | x | x | | | x | x | | x | x | | 58_Love | x | x | x | | | x | x | x | x | x | | 59_Lunar_LEM_Rocket | x | | x | | | | x | | x | x | | 60_Mastermind | x | x | x | | | x | x | | x | x | | 61_Math_Dice | x | x | x | | | x | x | x | x | x | | 62_Mugwump | x | x | x | | | x | x | | x | x | | 63_Name | x | x | x | x | | x | x | x | x | x | | 64_Nicomachus | x | x | x | | | x | x | | x | x | | 65_Nim | x | | x | | | | x | x | x | x | | 66_Number | x | x | x | | | x | x | | x | x | | 67_One_Check | x | x | x | | | x | x | | | x | | 68_Orbit | x | x | x | | | x | x | x | x | x | | 69_Pizza | x | x | x | | | x | x | x | x | x | | 70_Poetry | x | x | x | | | x | x | x | | x | | 71_Poker | x | x | x | | | | | | | x | | 72_Queen | x | | x | | | x | x | | x | x | | 73_Reverse | x | x | x | | | x | x | x | x | x | | 74_Rock_Scissors_Paper | x | x | x | x | | x | x | x | x | x | | 75_Roulette | x | x | x | | | x | x | | x | x | | 76_Russian_Roulette | x | x | x | x | | x | x | x | x | x | | 77_Salvo | x | | x | | | | x | | x | x | | 78_Sine_Wave | x | x | x | x | | x | x | x | x | x | | 79_Slalom | x | | x | | | | x | | | x | | 80_Slots | x | x | x | | | x | x | x | | x | | 81_Splat | x | x | x | | | x | x | | x | x | | 82_Stars | x | x | x | | | x | x | x | x | x | | 83_Stock_Market | x | x | x | | | | x | | | x | | 84_Super_Star_Trek | x | x | x | | | | x | | x | x | | 85_Synonym | x | x | x | | | x | x | x | x | x | | 86_Target | x | x | x | | | x | x | | | x | | 87_3-D_Plot | x | x | x | | | x | x | x | x | x | | 88_3-D_Tic-Tac-Toe | x | | x | | | | x | | | x | | 89_Tic-Tac-Toe | x | x | x | x | | x | x | | x | x | | 90_Tower | x | x | x | | | x | x | | x | x | | 91_Train | x | x | x | | | x | x | x | x | x | | 92_Trap | x | x | x | | | x | x | x | x | x | | 93_23_Matches | x | x | x | | | x | x | x | x | x | | 94_War | x | x | x | x | | x | x | x | x | x | | 95_Weekday | x | x | x | | | x | x | | x | x | | 96_Word | x | x | x | | | x | x | x | x | x |
--- ### Overview (`00_Alternate_Languages/README.md`) #### Alternate Languages This folder contains implementations of each program in alternate languages which are _not_ one of the agreed upon 10 languages. Implementations here are NOT bound to these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language So for example, (here only) C or PASCAL are allowed. Please still remain faithful to original look-and-feel (console applications). Try to keep your code portable (unless it is not possible, and then be very explicit about this limitation in your README and your folder naming). We welcome additional ports in whatever language you prefer, but these additional ports are for educational purposes only, and do not count towards the donation total at the end of the project. --- ### Overview (`00_Common/README.md`) # Common Library ## Purpose The primary purpose of this library is to implement common behaviours of the BASIC interpreter that impact gameplay, to free coders porting the games to concentrate on the explicit game logic. The behaviours implemented by this library are: * Complex interactions involved in text input. * Formatting of number in text output. * Behaviour of the BASIC `RND(float)` PRNG function. A secondary purpose is to provide common services that, with dependency injection, would allow a ported game to be driven programmatically to permit full-game acceptance tests to be written. The library is **NOT** intended to be: * a repository for common game logic that is implemented in the BASIC code of the games; or * a DSL allowing the BASIC code to be compiled in a different language environment with minimal changes. This implies that implementations of the above behaviours should use method names, etc, that are idiomatic of the specific language's normal routines for that behaviour. ## Text Input The behaviour of the BASIC interpreter when accepting text input from the user is a major element of the original gameplay experience that is seen to be valuable to maintain. This behaviour is complex and non-trivial to implement, and is better implemented once for other developers to use so they can concentrate on the explicit game logic. The text input/output behaviour can be investigated using a basic program such as: **`BASIC_Tests/InputTest.bas`** ```basic 10 INPUT "Enter 3 numbers";A,B,C 20 PRINT "You entered: ";A;B;C 30 PRINT "--------------------------" 40 GOTO 10 ``` The following transcript shows the use of this program, and some interesting behaviours of the BASIC interpreter INPUT routine. There are some other behaviours which can be seen in the unit tests for the C# library implementation. ``` /* Detailed source-code truncated for AI context efficiency. */ ``` I propose to ignore this last behaviour - the interpreter crash - and instead treat the end of the input line as the end of a quoted value. There are some additional behaviours to those shown above which can be seen in the unit tests for the C# implementation of the library. Note also that BASIC numeric variables store a single-precision floating point value, so numeric input functions should return a value of that type. ### Implementation Notes The usage of the `INPUT` command in the BASIC code of the games was analysed, with the variables used designated as `num`, for a numeric variable (eg. `M1`), or `str`, for a string variable (eg. `C$`). The result of this usage analysis across all game programs is: Variable number and type|Count ---|--- str|137 str str|2 num|187 num num|27 num num num|7 num num num num|1 num num num num num num num num num num|1 The usage count is interesting, but not important. What is important is the variable type and number for each usage. Implementers if the above behaviours do not need to cater for mixed variable types in their input routines (although the BASIC interpreter does support this). Input routines also need to cater only for 1 or 2 string values, and 1, 2, 3, 4, or 10 numeric values. ## Numbers in Text Output As seen in the transcript above, the BASIC interpreter has some particular rules for formatting numbers in text output. Negative numbers are printed with a leading negative sign (`-`) and a trailing space. Positive numbers are printed also with the trailing space, but with a leading space in place of the sign character. Additional formatting rules can be seen by running this program: **`BASIC_Tests/OutputTest.bas`** ```basic 10 A=1: B=-2: C=0.7: D=123456789: E=-0.0000000001 20 PRINT "|";A;"|";B;"|";C;"|";D;"|";E;"|" ``` The output is: ```dos | 1 |-2 | .7 | 1.2345679E+8 |-1.E-10 | ``` This clearly shows the leading and trailing spaces, but also shows that: * numbers without an integer component are printed without a leading zero to the left of the decimal place; * numbers above and below a certain magnitude are printed in scientific notation. ### Implementation Notes I think the important piece of this number formatting behaviour, in terms of its impact on replicating the text output of the original games, is the leading and trailing spaces. This should be the minimum behaviour supported for numeric output. Additional formatting behaviours may be investigated and supported by library implementers as they choose. ## The BASIC `RND(float)` function The [Vintage BASIC documentation](http://vintage-basic.net/downloads/Vintage_BASIC_Users_Guide.html) describes the behaviour of the `RND(float)` function: > Psuedorandom number generator. The behavior is different depending on the value passed. If the value is positive, the > result will be a new random value between 0 and 1 (including 0 but not 1). If the value is zero, the result will be a > repeat of the last random number generated. If the value is negative, it will be rounded down to the nearest integer > and used to reseed the random number generator. Pseudorandom sequences can be repeated by reseeding with the same > number. This behaviour can be shown by the program: **`BASIC_Tests/RndTest.bas`** ```basic 10 PRINT "1: ";RND(1);RND(1);RND(0);RND(0);RND(1) 20 PRINT "2: ";RND(-2);RND(1);RND(1);RND(1) 30 PRINT "3: ";RND(-5);RND(1);RND(1);RND(1) 40 PRINT "4: ";RND(-2);RND(1);RND(1);RND(1) ``` The output of this program is: ```dos 1: .97369444 .44256502 .44256502 .44256502 .28549057 <-- Repeated values due to RND(0) 2: .4986506 4.4510484E-2 .96231 .35997057 3: .8113741 .13687313 6.1034977E-2 .7874807 4: .4986506 4.4510484E-2 .96231 .35997057 <-- Same sequence as line 2 due to same seed ``` ### Implementation Notes While the BASIC `RND(x)` function always returns a number between 0 (inclusive) and 1 (exclusive) for positive non-zero values of `x`, game porters would find it convenient for the library to include functions returning a random float or integer in a range from an inclusive minimum to an exclusive maximum. As one of the games, "Football", makes use of `RND(0)` with different scaling applied than the previous use of `RND(1)`, a common library implementation should always generate a value between 0 and 1, and scale that for a function with a range, so that a call to the equivalent of the `RND(0)` function can return the previous value between 0 and 1. --- ### Overview (`00_Utilities/README.md`) #### Utilities These are global helper / utility programs to assist us in maintaining all the ports. --- ### Overview (`01_Acey_Ducey/README.md`) ### Acey Ducey This is a simulation of the Acey Ducey card game. In the game, the dealer (the computer) deals two cards face up. You have an option to bet or not to bet depending on whether or not you feel the next card dealt will have a value between the first two. Your initial money is set to $100; you may want to alter this value if you want to start with more or less than $100. The game keeps going on until you lose all your money or interrupt the program. The original program author was Bill Palmby of Prairie View, Illinois. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=2) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=17) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - Entering a negative bet allows you to gain arbitrarily large amounts of money upon losing the round. #### Porting Notes - The assignment `N = 100` in line 100 has no effect; variable `N` is not used anywhere else in the program. #### External Links - Common Lisp: https://github.com/koalahedron/lisp-computer-games/blob/master/01%20Acey%20Ducey/common-lisp/acey-deucy.lisp - PowerShell: https://github.com/eweilnau/basic-computer-games-powershell/blob/main/AceyDucey.ps1 --- ### Overview (`02_Amazing/README.md`) ### Amazing This program will print out a different maze every time it is run and guarantees only one path through. You can choose the dimensions of the maze — i.e. the number of squares wide and long. The original program author was Jack Hauber of Windsor, Connecticut. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=3) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=18) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - The input dimensions are checked for values of 1, but not for values of 0 or less. Such inputs will cause the program to break. #### Porting Notes **2022-01-04:** patched original source in [#400](https://github.com/coding-horror/basic-computer-games/pull/400) to fix a minor bug where a generated maze may be missing an exit, particularly at small maze sizes. --- ### Overview (`03_Animal/README.md`) ### Animal Unlike other computer games in which the computer picks a number or letter and you must guess what it is, in this game _you_ think of an animal and the _computer_ asks you questions and tries to guess the name of your animal. If the computer guesses incorrectly, it will ask you for a question that differentiates the animal you were thinking of. In this way the computer “learns” new animals. Questions to differentiate new animals should be input without a question mark. This version of the game does not have a SAVE feature. If your system allows, you may modify the program to save and reload the array when you want to play the game again. This way you can save what the computer learns over a series of games. At any time if you reply “LIST” to the question “ARE YOU THINKING OF AN ANIMAL,” the computer will tell you all the animals it knows so far. The program starts originally by knowing only FISH and BIRD. As you build up a file of animals you should use broad, general questions first and then narrow down to more specific ones with later animals. For example, if an elephant was to be your first animal, the computer would ask for a question to distinguish an elephant from a bird. Naturally, there are hundreds of possibilities, however, if you plan to build a large file of animals a good question would be “IS IT A MAMMAL.” This program can be easily modified to deal with categories of things other than animals by simply modifying the initial data and the dialogue references to animals. In an educational environment, this would be a valuable program to teach the distinguishing characteristics of many classes of objects — rock formations, geography, marine life, cell structures, etc. Originally developed by Arthur Luehrmann at Dartmouth College, Animal was subsequently shortened and modified by Nathan Teichholtz at DEC and Steve North at Creative Computing. --- As published in Basic Computer Games (1978) - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=4) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=19) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`04_Awari/README.md`) ### Awari Awari is an ancient African game played with seven sticks and thirty-six stones or beans laid out as shown above. The board is divided into six compartments or pits on each side. In addition, there are two special home pits at the ends. A move is made by taking all the beans from any (non-empty) pit on your own side. Starting from the pit to the right of this one, these beans are ‘sown’ one in each pit working around the board anticlockwise. A turn consists of one or two moves. If the last bean of your move is sown in your own home you may take a second move. If the last bean sown in a move lands in an empty pit, provided that the opposite pit is not empty, all the beans in the opposite pit, together with the last bean sown are ‘captured’ and moved to the player’s home. When either side is empty, the game is finished. The player with the most beans in his home has won. In the computer version, the board is printed as 14 numbers representing the 14 pits. ``` 3 3 3 3 3 3 0 0 3 3 3 3 3 3 ``` The pits on your (lower) side are numbered 1-6 from left to right. The pits on my (the computer’s) side are numbered from my left (your right). To make a move you type in the number of a pit. If the last bean lands in your home, the computer types ‘AGAIN?’ and then you type in your second move. The computer’s move is typed, followed by a diagram of the board in its new state. The computer always offers you the first move. This is considered to be a slight advantage. There is a learning mechanism in the program that causes the play of the computer to improve as it playes more games. The original version of Awari is adopted from one originally written by Geoff Wyvill of Bradford, Yorkshire, England. --- As published in Basic Computer Games (1978) - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=6) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=21) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`05_Bagels/README.md`) ### Bagels In this game, the computer picks a 3-digit secret number using the digits 0 to 9 and you attempt to guess what it is. You are allowed up to twenty guesses. No digit is repeated. After each guess the computer will give you clues about your guess as follows: - PICO One digit is correct, but in the wrong place - FERMI One digit is in the correct place - BAGELS No digit is correct You will learn to draw inferences from the clues and, with practice, you’ll learn to improve your score. There are several good strategies for playing Bagels. After you have found a good strategy, see if you can improve it. Or try a different strategy altogether to see if it is any better. While the program allows up to twenty guesses, if you use a good strategy it should not take more than eight guesses to get any number. The original authors of this program are D. Resek and P. Rowe of the Lawrence Hall of Science, Berkeley, California. --- As published in Basic Computer Games (1978) - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=9) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=21) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`06_Banner/README.md`) ### Banner This program creates a large banner on a terminal of any message you input. The letters may be any dimension of you wish although the letter height plus distance from left-hand side should not exceed 6 inches. Experiment with the height and width until you get a pleasing effect on whatever terminal you are using. This program was written by Leonard Rosendust of Brooklyn, New York. --- As published in Basic Computer Games (1978) - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=10) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=25) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - The "SET PAGE" input, stored in `O$`, has no effect. It was probably meant as an opportunity for the user to set their pin-feed printer to the top of the page before proceeding. - The data values for each character are the bit representation of each horizontal row of the printout (vertical column of a character), plus one. Perhaps because of this +1, the original code (and some of the ports here) are much more complicated than they need to be. (please note any difficulties or challenges in porting here) --- ### Overview (`07_Basketball/README.md`) ### Basketball This program simulates a game of basketball between Dartmouth College and an opponent of your choice. You are the Dartmouth captain and control the type of shot and defense during the course of the game. There are four types of shots: 1. Long Jump Shot (30ft) 2. Short Jump Shot (15ft) 3. Lay Up 4. Set Shot Both teams use the same defense, but you may call it: - Enter (6): Press - Enter (6.5): Man-to-man - Enter (7): Zone - Enter (7.5): None To change defense, type "0" as your next shot. Note: The game is biased slightly in favor of Dartmouth. The average probability of a Dartmouth shot being good is 62.95% compared to a probability of 61.85% for their opponent. (This makes the sample run slightly remarkable in that Cornell won by a score of 45 to 42 Hooray for the Big Red!) Charles Bacheller of Dartmouth College was the original author of this game. --- As published in Basic Computer Games (1978) - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=12) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=27) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) ##### Original bugs ###### Initial defense selection If a number <6 is entered for the starting defense then the original code prompts again until a value >=6 is entered, but then skips the opponent selection center jump. The C# port does not reproduce this behavior. It does prompt for a correct value, but will then go to opponent selection followed by the center jump. ###### Unvalidated defense selection The original code does not validate the value entered for the defense beyond checking that it is >=6. A large enough defense value will guarantee that all shots are good, and the game gets rather predictable. This bug is preserved in the C# port. --- ### Overview (`08_Batnum/README.md`) ### Batnum The game starts with an imaginary pile of objects, coins for example. You and your opponent (the computer) alternately remove objects from the pile. You specify in advance the minimum and maximum number of objects that can be taken on each turn. You also specify in advance how winning is defined: 1. To take the last object 2. To avoid taking the last object You may also determine whether you or the computer go first. The strategy of this game is based on modulo arithmetic. If the maximum number of objects a player may remove in a turn is M, then to gain a winning position a player at the end of his turn must leave a stack of 1 modulo (M+1) coins. If you don’t understand this, play the game 23 Matches first, then BATNUM, and have fun! BATNUM is a generalized version of a great number of manual remove-the-object games. The original computer version was written by one of the two originators of the BASIC language, John Kemeny of Dartmouth College. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=14) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=29) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - Though the instructions say "Enter a negative number for new pile size to stop playing," this does not actually work. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`09_Battle/README.md`) ### Battle BATTLE is based on the popular game Battleship which is primarily played to familiarize people with the location and designation of points on a coordinate plane. BATTLE first randomly sets up the bad guy’s fleet disposition on a 6 by 6 matrix or grid. The fleet consists of six ships: - Two destroyers (ships number 1 and 2) which are two units long - Two cruisers (ships number 3 and 4) which are three units long - Two aircraft carriers (ships number 5 and 6) which are four units long The program then prints out this fleet disposition in a coded or disguised format (see the sample computer print-out). You then proceed to sink the various ships by typing in the coordinates (two digits. each from 1 to 6, separated by a comma) of the place where you want to drop a bomb, if you’ll excuse the expression. The computer gives the appropriate response (splash, hit, etc.) which you should record on a 6 by 6 matrix. You are thus building a representation of the actual fleet disposition which you will hopefully use to decode the coded fleet disposition printed out by the computer. Each time a ship is sunk, the computer prints out which ships have been sunk so far and also gives you a “SPLASH/HIT RATIO.” The first thing you should learn is how to locate and designate positions on the matrix, and specifically the difference between “3,4” and “4,3.” Our method corresponds to the location of points on the coordinate plane rather than the location of numbers in a standard algebraic matrix: the first number gives the column counting from left to right and the second number gives the row counting from bottom to top. The second thing you should learn about is the splash/hit ratio. “What is a ratio?” A good reply is “It’s a fraction or quotient.” Specifically, the spash/hit ratio is the number of splashes divided by the number of hits. If you had 9 splashes and 15 hits, the ratio would be 9/15 or 3/5, both of which are correct. The computer would give this splash/hit ratio as .6. The main objective and primary education benefit of BATTLE comes from attempting to decode the bad guys’ fleet disposition code. To do this, you must make a comparison between the coded matrix and the actual matrix which you construct as you play the game. The original author of both the program and these descriptive notes is Ray Westergard of Lawrence Hall of Science, Berkeley, California. --- As published in Basic Computer Games (1978) - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=15) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=30) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - The original game has no way to re-view the fleet disposition code once it scrolls out of view. Ports should consider allowing the user to enter "?" at the "??" prompt, to reprint the disposition code. (This is added by the MiniScript port under Alternate Languages, for example.) --- ### Overview (`10_Blackjack/README.md`) ### Blackjack This is a simulation of the card game of Blackjack or 21, Las Vegas style. This rather comprehensive version allows for up to seven players. On each hand a player may get another card (a hit), stand, split a hand in the event two identical cards were received or double down. Also, the dealer will ask for an insurance bet if he has an exposed ace. Cards are automatically reshuffled as the 51st card is reached. For greater realism, you may wish to change this to the 41st card. Actually, fanatical purists will want to modify the program so it uses three decks of cards instead of just one. This program originally surfaced at Digital Equipment Corp.; the author is unknown. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=18) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=33) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes The program makes extensive use of the assumption that a boolean expression evaluates to **-1** for true. This was the case in some classic BASIC environments but not others; and it is not the case in [JS Basic](https://troypress.com/wp-content/uploads/user/js-basic/index.html), leading to nonsensical results. In an environment that uses **1** instead of **-1** for truth, you would need to negate the boolean expression in the following lines: - 10 - 570 - 590 - 2220 - 2850 - 3100 - 3400 - 3410 - 3420 --- ### Overview (`11_Bombardment/README.md`) ### Bombardment BOMBARDMENT is played on two, 5x5 grids or boards with 25 outpost locations numbered 1 to 25. Both you and the computer have four platoons of troops that can be located at any four outposts on your respective grids. At the start of the game, you locate (or hide) your four platoons on your grid. The computer does the same on its grid. You then take turns firing missiles or bombs at each other’s outposts trying to destroy all four platoons. The one who finds all four opponents’ platoons first, wins. This program was slightly modified from the original written by Martin Burdash of Parlin, New Jersey. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=22) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=37) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - Though the instructions say you can't place two platoons on the same outpost, the code does not enforce this. So the player can "cheat" and guarantee a win by entering the same outpost number two or more times. #### Porting Notes - To ensure the instructions don't scroll off the top of the screen, we may want to insert a "(Press Return)" or similar prompt before printing the tear-off matrix. (please note any difficulties or challenges in porting here) --- ### Overview (`12_Bombs_Away/README.md`) ### Bombs Away In this program, you fly a World War II bomber for one of the four protagonists of the war. You then pick your target or the type of plane you are flying. Depending on your flying experience and the quality of enemy defenders, you then may accomplish your mission, get shot down, or make it back through enemy fire. In any case, you get a chance to fly again. David Ahl modified the original program which was created by David Sherman while a student at Curtis Jr. High School, Sudbury, Massachusetts. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=24) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=39) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - If you play as Japan and say it is not your first mission, it is impossible to complete your mission; the only possible outcomes are "you made it through" or "boom". Moreover, the odds of each outcome depend on a variable (R) that is only set if you played a previous mission as a different side. It's possible this is an intentional layer of complexity meant to encourage repeat play, but it's more likely just a logical error. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`13_Bounce/README.md`) ### Bounce This program plots a bouncing ball. Most computer plots run along the paper in the terminal (top to bottom); however, this plot is drawn horizontally on the paper (left to right). You may specify the initial velocity of the ball and the coefficient of elasticity of the ball (a superball is about 0.85 — other balls are much less). You also specify the time increment to be used in “strobing” the flight of the ball. In other words, it is as though the ball is thrown up in a darkened room and you flash a light at fixed time intervals and photograph the progress of the ball. The program was originally written by Val Skalabrin while he was at DEC. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=25) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=40) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`14_Bowling/README.md`) ### Bowling This is a simulated bowling game for up to four players. You play 10 frames. To roll the ball, you simply type “ROLL.” After each roll, the computer will show you a diagram of the remaining pins (“0” means the pin is down, “+” means it is still standing), and it will give you a roll analysis: - GUTTER - STRIKE - SPARE - ERROR (on second ball if pins still standing) Bowling was written by Paul Peraino while a student at Woodrow Wilson High School, San Francisco, California. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=26) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=41) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - In the original code, scores is not kept accurately in multiplayer games. It stores scores in F*P, where F is the frame and P is the player. So, for example, frame 8 player 1 (index 16) clobbers the score from frame 4 player 2 (also index 16). - Even when scores are kept accurately, they don't match normal bowling rules. In this game, the score for each ball is just the total number of pins down after that ball, and the third row of scores is a status indicator (3 for strike, 2 for spare, 1 for anything else). - The program crashes with a "NEXT without FOR" error if you elect to play again after the first game. #### Porting Notes - The funny control characters in the "STRIKE!" string literal are there to make the terminal beep. --- ### Overview (`15_Boxing/README.md`) ### Boxing This program simulates a three-round Olympic boxing match. The computer coaches one of the boxers and determines his punches and defences, while you do the same for your boxer. At the start of the match, you may specify your man’s best punch and his vulnerability. There are approximately seven major punches per round, although this may be varied. The best out of three rounds wins. Jesse Lynch of St. Paul, Minnesota created this program. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=28) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=43) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - The code that handles player punch type 1 checks for opponent weakness type 4; this is almost certainly a mistake. - Line breaks or finishing messages are omitted in various cases. For example, if the player does a hook, and that's the opponent's weakness, then 7 points are silently awarded without outputting any description or line break, and the next sub-round will begin on the same line. - When the opponent selects a hook, control flow falls through to the uppercut case. Perhaps related, a player weakness of type 2 (hook) never has any effect on the game. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`16_Bug/README.md`) ### Bug The object of this game is to finish your drawing of a bug before the computer finishes. You and the computer roll a die alternately with each number standing for a part of the bug. You must add the parts in the right order; in other words, you cannot have a neck until you have a body, you cannot have a head until you have a neck, and so on. After each new part has been added, you have the option of seeing pictures of the two bugs. If you elect to see all the pictures, this program has the ability of consuming well over six feet of terminal paper per run. We can only suggest recycling the paper by using the other side. Brian Leibowitz wrote this program while in the 7th grade at Harrison Jr-Se High School in Harrison, New York. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=30) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=45) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`17_Bullfight/README.md`) ### Bullfight In this simulated bullfight, you are the matador — i.e., the one with the principle role and the one who must kill the bull or be killed (or run from the ring). On each pass of the bull, you may try: - 0: Veronica (dangerous inside move of the cape) - 1: Less dangerous outside move of the cape - 2: Ordinary swirl of the cape Or you may try to kill the bull: - 4: Over the horns - 5: In the chest The crowd will determine what award you deserve, posthumously if necessary. The braver you are, the better the reward you receive. It’s nice to stay alive too. The better the job the picadores and toreadores do, the better your chances. David Sweet of Dartmouth wrote the original version of this program. It was then modified by students at Lexington High School and finally by Steve North of Creative Computing. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=32) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=47) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - There is a fundamental assumption in the pre-fight subroutine at line 1610, that the Picadores and Toreadores are more likely to do a bad job (and possibly get killed) with a low-quality bull. This appears to be a mistake in the original code, but should be retained. - Lines 1800-1820 (part of the pre-fight subroutine) can never be reached. --- ### Overview (`18_Bullseye/README.md`) ### Bullseye In this game, up to 20 players throw darts at a target with 10-, 20-, 30-, and 40-point zones. The objective is to get 200 points. You have a choice of three methods of throwing: | Throw | Description | Probable Score | |-------|--------------------|---------------------------| | 1 | Fast overarm | Bullseye or complete miss | | 2 | Controlled overarm | 10, 20, or 30 points | | 3 | Underarm | Anything | You will find after playing a while that different players will swear by different strategies. However, considering the expected score per throw by always using throw 3: | Score (S) | Probability (P) | S x P | |-----------|-----------------|-------| | 40 | 1.00-.95 = .05 | 2 | | 30 | .95-.75 = .20 | 6 | | 30 | .75-.45 = .30 | 6 | | 10 | .45-.05 = .40 | 4 | | 0 | .05-.00 = .05 | 0 | Expected score per throw = 18 Calculate the expected score for the other throws and you may be surprised! The program was written by David Ahl of Creative Computing. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=34) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=49) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`19_Bunny/README.md`) ### Bunny As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=35) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=50) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`20_Buzzword/README.md`) ### Buzzword This program is an invaluable aid for preparing speeches and briefings about educational technology. This buzzword generator provides sets of three highly-acceptable words to work into your material. Your audience will never know that the phrases don’t really mean much of anything because they sound so great! Full instructions for running are given in the program. This version of Buzzword was written by David Ahl. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=36) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=51) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`21_Calendar/README.md`) ### Calendar This program prints out a calendar for any year. You must specify the starting day of the week of the year: - 0: Sunday - -1: Monday - -2: Tuesday - -3: Wednesday - -4: Thursday - -5: Friday - -6: Saturday You can determine this by using the program WEEKDAY. You must also make two changes for leap years. The program listing describes the necessary changes. Running the program produces a nice 12-month calendar. The program was written by Geoffrey Chase of the Abbey, Portsmouth, Rhode Island. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=37) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=52) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - While many modern environments have time/date functions that would make this program both easier and more automatic, in these ports we are choosing to do without them, as in the original program. - Some ports choose to ask the user the starting day of week, and whether it's a leap year, rather than force changes to the code to fit the desired year. --- ### Overview (`22_Change/README.md`) ### Change In this program, the computer pretends it is the cashier at your friendly neighborhood candy store. You tell it the cost of the item(s) you are buying, the amount of your payment, and it will automatically (!) determine your correct change. Aren’t machines wonderful? Dennis Lunder of People’s Computer Company wrote this program. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=39) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=54) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`23_Checkers/README.md`) ### Checkers This program plays checkers. The pieces played by the computer are marked with an “X”, yours are marked “O”. A move is made by specifying the coordinates of the piece to be moved (X, Y). Home (0,0) is in the bottom left and X specifies distance to the right of home (i.e., column) and Y specifies distance above home (i.e. row). You then specify where you wish to move to. The original version of the program by Alan Segal was not able to recognize (or permit) a double or triple jump. If you tried one, it was likely that your piece would disappear altogether! Steve North of Creative Computing rectified this problem and Lawrence Neal contributed modifications to allow the program to tell which player has won the game. The computer does not play a particularly good game but we leave it to _you_ to improve that. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=40) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=55) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html The file `checkers.annotated.bas` contains an indented and annotated version of the source code. This is no longer valid BASIC code but should be more readable. #### Porting Notes - If the computer moves a checker to the bottom row, it promotes, but leaves the original checker in place. (See line 1240) - Human players may move non-kings as if they were kings. (See lines 1590 to 1810) - Human players are not required to jump if it is possible, and may make a number other illegal moves (jumping their own pieces, jumping empty squares, etc.). - Curious writing to "I" variable without ever reading it. (See lines 1700 and 1806) --- ### Overview (`24_Chemist/README.md`) ### Chemist The fictitious chemical, kryptocyanic acid, can only be diluted by the ratio of 7 parts water to 3 parts acid. Any other ratio causes an unstable compound which soon explodes. Given an amount of acid, you must determine how much water to add to the dilution. If you’re more than 5% off, you lose one of your nine lives. The program continues to play until you lose all nine lives or until it is interrupted. It was originally written by Wayne Teeter of Ridgecrest, California. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=42) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=57) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - There is a typo in the original Basic, "...DECIDE **WHO** MUCH WATER..." should be "DECIDE **HOW** MUCH WATER" #### Porting Notes (please note any difficulties or challenges in porting here) #### External Links - C: https://github.com/ericfischer/basic-computer-games/blob/main/24%20Chemist/c/chemist.c --- ### Overview (`25_Chief/README.md`) ### Chief In the words of the program author, John Graham, “CHIEF is designed to give people (mostly kids) practice in the four operations (addition, multiplication, subtraction, and division). It does this while giving people some fun. And then, if the people are wrong, it shows them how they should have done it. CHIEF was written by John Graham of Upper Brookville, New York. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=43) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=58) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`26_Chomp/README.md`) ### Chomp This program is an adaptation of a mathematical game originally described by Martin Gardner in the January 1973 issue of _Scientific American_. Up to a 9x9 grid is set up by you with the upper left square in a poison square. This grid is the cookie. Players alternately chomp away at the cookie from the lower right. To take a chomp, input a row and column number of one of the squares remaining on the cookie. All of the squares below and to the right of that square, including that square, disappear. Any number of people can play — the computer is only the moderator; it is not a player. Two-person strategies are interesting to work out but strategies when three or more people are playing are the real challenge. The computer version of the game was written by Peter Sessions of People’s Computer Company. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=44) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=59) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`27_Civil_War/README.md`) ### Civil War This simulation is based on 14 battles in the Civil War. Facts and figures are based on the actual occurrence. If you follow the same strategy used in the actual battle, the results will be the same. Generally, this is a good strategy since the generals in the Civil War were fairly good military strategists. However, you can frequently outperform the Civil War generals, particularly in cases where they did not have good enemy intelligence and consequently followed a poor course of action. Naturally, it helps to know your Civil War history, although the computer gives you the rudiments. After each of the 14 battles, your casualties are compared to the actual casualties of the battle, and you are told whether you win or lose the battle. You may play Civil War alone in which case the program simulates the Union general. Or two players may play in which case the computer becomes the moderator. Civil War was written in 1968 by three Students in Lexington High School, Massachusetts: L. Cram, L. Goodie, and D. Hibbard. It was modified into a 2-player game by G. Paul and R. Hess of TIES, St. Paul, Minnesota. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=46) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=61) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - At the end of a single-player game, the program reports strategies used by "THE SOUTH", but these are in fact strategies used by the North (the computer player) -- the South is always a human player. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`28_Combat/README.md`) ### Combat In this game, you are fighting a small-scale war with the computer. You have 72,000 troops which you first ust distribute among your Army, Navy, and Air Force. You may distribute them in any way you choose as long as you don’t use more than 72,000. You then attack your opponent (the computer) and input which service and the number of men you wish to use. The computer then tells you the outcome of the battle, gives you the current statistics and allows you to determine your next move. After the second battle, it is decided from the total statistics whether you win or lose or if a treaty is signed. This program was created by Bob Dores of Milton, Massachusetts. As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=50) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=65) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - The original game misspells "unguarded" on line 1751. - In an initial army attack, the program claims that the computer loses 2/3 of its army, but it actually loses its entire army (lines 150-155). #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`29_Craps/README.md`) ### Craps This game simulates the game of craps played according to standard Nevada craps table rules. That is: 1. A 7 or 11 on the first roll wins 2. A 2, 3, or 12 on the first roll loses 3. Any other number rolled becomes your “point.” - You continue to roll, if you get your point, you win. - If you roll a 7, you lose and the dice change hands when this happens. This version of craps was modified by Steve North of Creative Computing. It is based on an original which appeared one day on a computer at DEC. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=52) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=67) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes 15 LET R=0 `R` is a variable that tracks winnings and losings. Unlike other games that start out with a lump sum of cash to spend this game assumes the user has as much money as they want and we only track how much they lost or won. 21 LET T=1 22 PRINT "PICK A NUMBER AND INPUT TO ROLL DICE"; 23 INPUT Z 24 LET X=(RND(0)) 25 LET T =T+1 26 IF T<=Z THEN 24 This block of code does nothing other than try to scramble the random number generator. Random number generation is not random, they are generated from the previous generated number. Because of the slow speed of these systems back then, gaming random number generators was a concern, mostly for gameplay quality. If you could know the "seed value" to the generator then you could effectively know how to get the exact same dice rolls to happen and change your bet to maximize your winnings and minimize your losses. The first reason this is an example of bad coding practice is the user is asked to input a number but no clue is given as to the use of this number. This number has no bearing on the game and as we'll see only has bearing on the internal implementation of somehow trying to get an un-game-able seed for the random number generator (since all future random numbers generated are based off this seed value.) The `RND(1)` command generates a number from a seed value that is always the same, everytime, from when the machine is booted up (old C64 behavior). In order to avoid the same dice rolls being generated, a special call to `RND(-TI)` would initialize the random generator with something else. But RND(-TI) is not a valid command on all systems. So `RND(0)`, which generates a random number from the system clock is used. But technically this could be gamed because the system clock was driven by the bootup time, there wasn't a BIOS battery on these systems that kept an internal real time clock going even when the system was turned off, unlike your regular PC. Therefore, in order to ensure as true randomness as possible, insert human reaction time by asking for human input. But a human could just be holding down the enter key on bootup and that would just skip any kind of multi-millisecond variance assigned by a natural human reaction time. So, paranoia being a great motivator, a number is asked of the user to avoid just holding down the enter key which negates the timing variance of a human reaction. What comes next is a bit of nonsense. The block of code loops a counter, recalling the `RND(0)` function (and thus reseeding it with the system clock value) and then comparing the counter to the user's number input in order to bail out of the loop. Because the `RND(0)` function is based off the system clock and the loop of code has no branching other than the bailout condition, the loop also takes a fixed amount of time to execute, thus making repeated calls to `RND(0)` predictive and this scheming to get a better random number is pointless. Furthermore, the loop is based on the number the user inputs so a huge number like ten million causes a very noticable delay and leaves the user wondering if the program has errored. The author could have simply called `RND(0)` once and used a prompt that made more sense like asking for the users name and then using that name in the game's replies. It is advised that you use whatever your languages' random number generator provides and simply skip trying to recreate this bit of nonsense including the user input. 27 PRINT"INPUT THE AMOUNT OF YOUR WAGER."; 28 INPUT F 30 PRINT "I WILL NOW THROW THE DICE" 40 LET E=INT(7*RND(1)) 41 LET S=INT(7*RND(1)) 42 LET X=E+S .... a bit later .... 60 IF X=1 THEN 40 65 IF X=0 THEN 40 `F` is a variable that represents the users wager for this betting round. `E` and `S` represent the two individual and random dice being rolled. This code is actually wrong because it returns a value between 0 and 6. `X` is the sum of these dice rolls. As you'll see though further down in the code, if `X` is zero or one it re-rolls the dice to maintain a potential outcome of the sum of two dice between 2 and 12. This skews the normal distribution of dice values to favor lower numbers because it does not consider that `E` could be zero and `S` could be 2 or higher. To show this skewing of values you can run the `distribution.bas` program which creates a histogram of the distribution of the bad dice throw code and proper dice throw code. Here are the results: DISTRIBUTION OF DICE ROLLS WITH INT(7*RND(1)) VS INT(6*RND(1)+1) THE INT(7*RND(1)) DISTRIBUTION: 2 3 4 5 6 7 8 9 10 11 12 6483 8662 10772 13232 15254 13007 10746 8878 6486 4357 2123 THE INT(6*RND(1)+1) DISTRIBUTION 2 3 4 5 6 7 8 9 10 11 12 2788 5466 8363 11072 13947 16656 13884 11149 8324 5561 2790 If the dice rolls are fair then we should see the largest occurrence be a 7 and the smallest should be 2 and 12. Furthermore the occurrences should be symetrical meaning there should be roughly the same amount of 2's as 12's, the same amount of 3's as 11's, 4's as 10's and so on until you reach the middle, 7. But notice in the skewed dice roll, 6 is the most rolled number not 7, and the rest of the numbers are not symetrical, there are many more 2's than 12's. So the lesson is test your code. The proper way to model a dice throw, in almost every language is `INT(6*RND(1)+1)` or `INT(6*RND(1))+1` SideNote: `X` was used already in the previous code block discussed but its value was never used. This is another poor coding practice: **Don't reuse variable names for different purposes.** 50 IF X=7 THEN 180 55 IF X=11 THEN 180 60 IF X=1 THEN 40 62 IF X=2 THEN 195 65 IF X=0 THEN 40 70 IF X=2 THEN 200 80 IF X=3 THEN 200 90 IF X=12 THEN 200 125 IF X=5 THEN 220 130 IF X =6 THEN 220 140 IF X=8 THEN 220 150 IF X=9 THEN 220 160 IF X =10 THEN 220 170 IF X=4 THEN 220 This bit of code determines the routing of where to go for payout, or loss. Of course, line 60 and 65 are pointless as we've just shown and should be removed as long as the correct dice algorithm is also changed. 62 IF X=2 THEN 195 .... 70 IF X=2 THEN 200 The check for a 2 has already been made and the jump is done. Line 70 is therefore redundant and can be left out. The purpose of line 62 is only to print a special output, "SNAKE EYES!" which we'll see in the next block creates duplicate code. Lines 125-170 are also pointlessly checked because we know previous values have been ruled out, only these last values must remain, and they are all going to the same place, line 220. Line 125-170 could have simply been replaced with `GOTO 220` 180 PRINT X "- NATURAL....A WINNER!!!!" 185 PRINT X"PAYS EVEN MONEY, YOU WIN"F"DOLLARS" 190 GOTO 210 195 PRINT X"- SNAKE EYES....YOU LOSE." 196 PRINT "YOU LOSE"F "DOLLARS." 197 LET F=0-F 198 GOTO 210 200 PRINT X " - CRAPS...YOU LOSE." 205 PRINT "YOU LOSE"F"DOLLARS." 206 LET F=0-F 210 LET R= R+F 211 GOTO 320 This bit of code manages instant wins or losses due to 7,11 or 2,3,12. As mentioned previously, lines 196 and 197 are essentially the same as lines 205 and 206. A simpler code would be just to jump after printing the special message of "SNAKE EYES!" to line 205. Lines 197 and 206 just negate the wager by subtracting it from zero. Just saying `F = -F` would have sufficed. Line 210 updates your running total of winnings or losses with this bet. 220 PRINT X "IS THE POINT. I WILL ROLL AGAIN" 230 LET H=INT(7*RND(1)) 231 LET Q=INT(7*RND(1)) 232 LET O=H+Q 240 IF O=1 THEN 230 250 IF O=7 THEN 290 255 IF O=0 THEN 230 This code sets the point, the number you must re-roll to win without rolling a 7, the most probable number to roll. Except in this case again, it has the same incorrect dice rolling code and therefore 6 is the most probable number to roll. The concept of DRY (don't repeat yourself) is a coding practice which encourages non-duplication of code because if there is an error in the code, it can be fixed in one place and not multiple places like in this code. The scenario might be that a programmer sees some wrong code, fixes it, but neglects to consider that there might be duplicates of the same wrong code elsewhere. If you practice DRY then you never worry much about behaviors in your code diverging due to duplicate code snippets. 260 IF O=X THEN 310 270 PRINT O " - NO POINT. I WILL ROLL AGAIN" 280 GOTO 230 290 PRINT O "- CRAPS. YOU LOSE." 291 PRINT "YOU LOSE $"F 292 F=0-F 293 GOTO 210 300 GOTO 320 310 PRINT X"- A WINNER.........CONGRATS!!!!!!!!" 311 PRINT X "AT 2 TO 1 ODDS PAYS YOU...LET ME SEE..."2*F"DOLLARS" 312 LET F=2*F 313 GOTO 210 This is the code to keep rolling until the point is made or a seven is rolled. Again we see the negated `F` wager and lose message duplicated. This code could have been reorganized using a subroutine, or in BASIC, the GOSUB command, but in your language its most likely just known as a function or method. You can do a `grep -r 'GOSUB'` from the root directory to see other BASIC programs in this set that use GOSUB. The rest of the code if fairly straight forward, replay the game or end with a report of your winnings or losings. --- ### Overview (`30_Cube/README.md`) ### Cube CUBE is a game played on the facing sides of a cube with a side dimension of 2. A location is designated by three numbers — e.g., 1, 2, 1. The object is to travel from 1, 1, 1 to 3, 3, 3 by moving one horizontal or vertical (not diagonal) square at a time without striking one of 5 randomly placed landmines. You are staked to $500; prior to each play of the game you may make a wager whether you will reach your destination. You lose if you hit a mine or try to make an illegal move — i.e., change more than one digit from your previous position. Cube was created by Jerimac Ratliff of Fort Worth, Texas. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=53) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=68) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) ##### Known Bugs This program does very little validation of its input, enabling the user to cheat in two ways: - One can enter a large negative wager, purposely lose, and gain that much money. - One can move outside the cube (using coordinates 0 or 4), then safely walk "around" the standard play volume to the destination square. It's remotely possible that these are clever solutions the user is intended to find, solving an otherwise purely random game. ##### Randomization Logic The BASIC code uses an interesting technique for choosing the random coordinates for the mines. The first coordinate is chosen like this: ```basic 380 LET A=INT(3*(RND(X))) 390 IF A<>0 THEN 410 400 LET A=3 ``` where line 410 is the start of a similar block of code for the next coordinate. The behaviour of `RND(X)` depends on the value of `X`. If `X` is greater than zero then it returns a random value between 0 and 1. If `X` is zero it returns the last random value generated, or 0 if no value has yet been generated. If `X` is 1, therefore, the first line above set `A` to 0, 1, or 2. The next 2 lines replace a 0 with a 3. The replacement values varies for the different coordinates with the result that the random selection is biased towards a specific set of points. If `X` is 0, the `RND` calls all return 0, so the coordinates are the known. It appears that this technique was probably used to allow testing the game with a well-known set of locations for the mines. However, in the code as it comes to us, the value of `X` is never set and is thus 0, so the mine locations are never randomized. The C# port implements the biased randomized mine locations, as seems to be the original intent, but includes a command-line switch to enable the deterministic execution as well. --- ### Overview (`31_Depth_Charge/README.md`) ### Depth Charge In this program you are captain of the destroyer USS Computer. An enemy submarine has been causing trouble and your mission is to destroy it. You may select the seize of the “cube” of water you wish to search in. The computer then determines how many depth charges you get to destroy the submarine. Each depth charge is exploded by you specifying a trio of numbers; the first two are the surface coordinates (X,Y), the third is the depth. After each depth charge, your sonar observer will tell you where the explosion was relative to the submarine. Dana Noftle wrote this program while a student at Acton High School, Acton, Massachusetts. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=55) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=70) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`32_Diamond/README.md`) ### Diamond This program fills an 8.5x11 piece of paper with diamonds (plotted on a hard-copy terminal, of course). The program asks for an odd number to be input in the range 5 to 31. The diamonds printed will be this number of characters high and wide. The number of diamonds across the page will vary from 12 for 5-character wide diamonds to 1 for a diamond 31-characters wide. You can change the content of the pattern if you wish. The program was written by David Ahl of Creative Computing. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=56) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=71) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`33_Dice/README.md`) ### Dice Not exactly a game, this program simulates rolling a pair of dice a large number of times and prints out the frequency distribution. You simply input the number of rolls. It is interesting to see how many rolls are necessary to approach the theoretical distribution: | | | | |---|------|------------| | 2 | 1/36 | 2.7777...% | | 3 | 2/36 | 5.5555...% | | 4 | 3/36 | 8.3333...% | etc. Daniel Freidus wrote this program while in the seventh grade at Harrison Jr-Sr High School, Harrison, New York. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=57) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=72) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`34_Digits/README.md`) ### Digits The player writes down a set of 30 numbers (0, 1, or 2) at random prior to playing the game. The computer program, using pattern recognition techniques, attempts to guess the next number in your list. The computer asks for 10 numbers at a time. It always guesses first and then examines the next number to see if it guessed correctly. By pure luck (or chance or probability), the computer ought to be right 10 times. It is uncanny how much better it generally does than that! This program originated at Dartmouth; original author unknown. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=58) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=73) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - The program contains a lot of mysterious and seemingly arbitrary constants. It's not clear there is any logic or rationality behind it. - The key equation involved in the guess (line 700) involves a factor of `A`, but `A` is always 0, making that term meaningless. As a result, all the work to build and update array K and value Z2 appear to be meaningless, too. --- ### Overview (`35_Even_Wins/README.md`) ### Even Wins This is a game between you and the computer. To play, an odd number of objects (marbles, chips, matches) are placed in a row. You take turns with the computer picking up between one and four objects each turn. The game ends when there are no objects left, and the winner is the one with an even number of objects picked up. Two versions of this game are included. While to the player they appear similar, the programming approach is quite different. EVEN WINS, the first version, is deterministic — i.e., the computer plays by fixed, good rules and is impossible to beat if you don’t know how to play the game. It always starts with 27 objects, although you may change this. The second version, GAME OF EVEN WINS, is much more interesting because the computer starts out only knowing the rules of the game. Using simple techniques of artificial intelligence (cybernetics), the computer gradually learns to play this game from its mistakes until it plays a very good game. After 20 games, the computer is a challenge to beat. Variation in the human’s style of play seems to make the computer learn more quickly. If you plot the learning curve of this program, it closely resembles classical human learning curves from psychological experiments. Eric Peters at DEC wrote the GAME OF EVEN WINS. The original author of EVEN WINS is unknown. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=60) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=75) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`36_Flip_Flop/README.md`) ### Flip Flop The object of this game is to change a row of ten X’s ``` X X X X X X X X X X ``` to a row of ten 0’s ``` 0 0 0 0 0 0 0 0 0 0 ``` by typing in a number corresponding to the position of an “X” in the line. On some numbers one position will change while on other numbers, two will change. For example, inputting a 3 may reverse the X and 0 in position 3, but it might possibly reverse some of other position too! You ought to be able to change all 10 in 12 or fewer moves. Can you figure out a good winning strategy? To reset the line to all X’s (same game), type 0 (zero). To start a new game at any point, type 11. The original author of this game was Micheal Kass of New Hyde Park, New York. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=63) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=78) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`37_Football/README.md`) ### Football Football is probably the most popular simulated sports game. I have seen some people play to elect to play computerized football in preference to watching a football game on television. Two versions of football are presented. The first is somewhat “traditional” in that you, the player, are playing against the computer. You have a choice of seven offensive plays. On defense the computer seems to play a zone defence, but you have no choice of plays. The computer program presents the necessary rules as you play, and it is also the referee and determines penalties when an infraction is committed. FTBALL was written by John Kemeny at Dartmouth. IN the second version of football, the computer referees a game played between two human players. Each player gets a list of twenty plays with a code value for each one. This list should be kept confidential from your opponent. The codes can be changes in data. All twenty plays are offensive; a defensive play is specified by defending against a type of offensive play. A defense is good for other similar types of plays, for example, a defense against a flare pass is very good against a screen pass but much less good against a half-back option. This game was originally written by Raymond Miseyka of Butler, Pennsylvania. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=64) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=79) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`38_Fur_Trader/README.md`) ### Fur Trader You are the leader of a French fur trading expedition in 1776 leaving the Ontario area to sell furs and get supplies for the next year. You have a choice of three forts at which you may trade. The cost of supplies and the amount you recieve for your furs will depend upon the fort you choose. You also specify what types of furs that you have to trade. The game goes on and on until you elect to trade no longer. Author of the program is Dan Bachor, University of Calgary, Alberta, Canada. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=69) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=84) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - The value of some furs are not changed from the previous fort when you select fort 2 or 3. As a result, you will get a different value for your firs depending on whether you have previously visited a different fort. (All fur values are set when you visit Fort 1.) #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`39_Golf/README.md`) ### Golf This is a single player golf game. In other words it’s you against the golf course (the computer). The program asks for your handicap (maximum of 30) and your area of difficulty. You have a bag of 29 clubs plus a putter. On the course you have to contend with rough, trees, on and off fairway, sand traps, and water hazards. In addition, you can hook, slice, go out of bounds, or hit too far. On putting, you determine the potency factor (or percent of swing). Until you get the swing of the game (no pun intended), you’ll probably was to use a fairly high handicap. Steve North of Creative Computing modified the original version of this game, the author of which is unknown. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=71) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=86) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - The weakness numbers printed in the original BASIC program are wrong. It says 4=TRAP SHOTS, 5=PUTTING, but in the code, trap shots and putting are 3 and 4, respectively. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`40_Gomoko/README.md`) ### Gomoko GOMOKO or GOMOKU is a traditional game of the Orient. It is played by two people on a board of intersecting lines (19 left-to-right lines, 19 top-to-bottom lines, 361 intersections in all). Players take turns. During his turn, a player may cover one intersection with a marker; (one player uses white markers; the other player uses black markers). The object of the game is to get five adjacent markers in a row, horizontally, vertically or along either diagonal. Unfortunately, this program does not make the computer a very good player. It does not know when you are about to win or even who has won. But some of its moves may surprise you. The original author of this program is Peter Sessions of People’s Computer Company. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=74) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=89) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`41_Guess/README.md`) ### Guess In Program GUESS, the computer chooses a random integer between 0 and any limit you set. You must then try to guess the number the computer has chosen using the clues provided by the computer. You should be able to guess the number in one less than the number of digits needed to represent the number in binary notation — i.e., in base 2. This ought to give you a clue as to the optimum search technique. GUESS converted from the original program in FOCAL which appeared in the book “Computers in the Classroom” by Walt Koetke of Lexington High School, Lexington, Massachusetts. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=75) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=90) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`42_Gunner/README.md`) ### Gunner GUNNER allows you to adjust the fire of a field artillery weapon to hit a stationary target. You specify the number of degrees of elevation of your weapon; 45 degrees provides maximum range with values under or over 45 degrees providing less range. You get up to five shots to destroy the enemy before he destroys you. Gun range varies between 20,000 and 60,000 yards and burst radius is 100 yards. You must specify elevation within approximately 0.2 degrees to get a hit. Tom Kloos of the Oregon Museum of Science and Industry in Portland, Oregon originally wrote GUNNER. Extensive modifications were added by David Ahl. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=77) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=92) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`43_Hammurabi/README.md`) ### Hammurabi In this game you direct the administrator of Sumeria, Hammurabi, how to manage the city. The city initially has 1,000 acres, 100 people and 3,000 bushels of grain in storage. You may buy and sell land with your neighboring city-states for bushels of grain — the price will vary between 17 and 26 bushels per acre. You also must use grain to feed your people and as seed to plant the next year’s crop. You will quickly find that a certain number of people can only tend a certain amount of land and that people starve if they are not fed enough. You also have the unexpected to contend with such as a plague, rats destroying stored grain, and variable harvests. You will also find that managing just the few resources in this game is not a trivial job over a period of say ten years. The crisis of population density rears its head very rapidly. This program was originally written in Focal at DEC; author unknown. David Ahl converted it to BASIC and added the 10-year performance assessment. If you wish to change any of the factors, the extensive remarks in the program should make modification fairly straightforward. Note for trivia buffs: somewhere along the line an m was dropped out of the spelling of Hammurabi in hte Ahl version of the computer program. This error has spread far and wide until a generation of students now think that Hammurabi is the incorrect spelling. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=78) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=93) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - Though the file name and README both spell "Hammurabi" with two M's, the program itself consistently uses only one M. #### External Links - C: https://github.com/beyonddream/hamurabi - Rust: https://github.com/beyonddream/hamurabi.rs --- ### Overview (`44_Hangman/README.md`) ### Hangman This is a simulation of the word guessing game, hangman. The computer picks a word, tells you how many letters in the word it has picked and then you guess a letter in the word. If you are right, the computer tells you where that letter belongs; if your letter is wrong, the computer starts to hang you. You get ten guesses before you are completely hanged: 1. Head 2. Body 3. Right Arm 4. Left Arm 5. Right Leg 6. Left Leg 7. Right Hand 8. Left Hand 9. Right Foot 10. Left Foot You may add words in Data statements; however if you do, you must also change the random word selector. David Ahl modified this program into its current form from the one created by Kenneth Aupperle of Melville, New York. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=80) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=95) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`45_Hello/README.md`) ### Hello This is a sample of one of the great number of conversational programs. In a sense, it is like a CAI program except that its responses are just good fun. Whenever a computer is exhibited at a convention or conference with people that have not used a computer before, the conversational programs seem to get the first activity. In this particular program, the computer dispenses advice on various problems such as sex, health, money, or job. David Ahl is the author of HELLO. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=82) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=97) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`46_Hexapawn/README.md`) ### Hexapawn The game of Hexapawn and a method to learn a strategy for playing the game was described in Martin Gardner’s “Mathematical Games” column in the March 1962 issue of _Scientific American_. The method described in the article was for a hypothetical learning machine composed of match boxes and colored beads. This has been generalized in the program HEX. The program learns by elimination of bad moves. All positions encountered by the program and acceptable moves from them are stored in an array. When the program encounters an unfamiliar position, the position and all legal moves from it are added to the list. If the program loses a game, it erases the move that led to defeat. If it hits a position from which all moves have been deleted (they all led to defeat), it erases the move that got it there and resigns. Eventually, the program learns to play extremely well and, indeed, is unbeatable. The learning strategy could be adopted to other simple games with a finite number of moves (tic-tac-toe, small board checkers, or other chess-based games). The original version of this program was written by R.A. Kaapke. It was subsequently modified by Jeff Dalton and finally by Steve North of Creative Computing. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=83) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=98) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - There are valid board positions that will cause the program to print "ILLEGAL BOARD PATTERN" and break. For example: human 8,5; computer 1,5; human 9,5; computer 3,5; human 7,5. This is a valid game-over pattern, but it is not detected as such because of incorrect logic in lines 240-320 (intended to detect whether the computer has any legal moves). #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`47_Hi-Lo/README.md`) ### Hi-Lo This game is an adaptation of the game GUESS; however, instead of just guessing a number between 1 and 100, in this game you win dollars when you guess the number. The directions, in the words of the author, are as follows: 1. There is an amount of money, between one and one hundred dollars, in the “HI-LO” jackpot. 2. You will have six chances in which to guess the amount of money in the jackpot. 3. After each guess, the computer will tell whether the guess was too high or too low. 4. If the correct amount of money is not guessed after six chances, the computer will print the amount in the jackpot. 5. If the correct amount of money is guessed within the six chance limit, the computer will register this amount. 6. After each sequence of guesses, you have the choice of playing again or ending the program. If a new game is played, a new amount of money will constitute the jackpot. 7. If youwin more than once, then your earnings are totalled. The author is Dean ALtman of Fort Worth, Texas. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=85) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=100) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`48_High_IQ/README.md`) ### High IQ This is a computerized version of an old European solitaire game of logic. The game starts with a pegboard shaped like a cross having pegs in every hole but the center. The object is to remove all 32 pegs, or as many as possible, by jumping into an empty hole, then removing the jumped peg. There are several different winning strategies for playing, and of course, each strategy can be played eight different ways on the board. Can you find a consistent winner? Charles Lund wrote this game while at The American School in The Hague, Netherlands. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=86) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=101) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`49_Hockey/README.md`) ### Hockey This is a simulation of a ice hockey game. The computer, in this case, moderates and referees the pay between two human opponents. Of course, one person could play both sides. The program asks for team names, player names, and even the name of the referee. Four types of shot are permitted and a shot may be aimed at one of four areas. You are also asked about passing. The game is very comprehensive with lots of action, face offs, blocks, passes, 4 on 2 situations, and so on. Unfortunately there are no penalties. The original author is Robert Puopolo; modifications by Steve North of Creative Computing. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=88) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=103) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - An apparent missing line 430 causes the code to fall through from the "FLIPS A WRISTSHOT" case directly to the "BACKHANDS ONE" case. - The author consistently misspells the verb "lets" (writing it like the contraction "let's"), while having no trouble with "leads", "gets", "hits", etc. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`50_Horserace/README.md`) ### Horserace This program simulates a one-mile horse race for three-year old throughbreds. Up to ten people may place bets on the race up to $10,000 each. However, you may only bet to win. You place your bet by inputting the number of the horse, a comma, and the amount of your bet. The computer then shows the position of the horses at seven points around the track and at the finish. Payoffs and winnings are shown at the end. The program was written by Laurie Chevalier while a student at South Portland High School. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=92) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=107) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`51_Hurkle/README.md`) ### Hurkle Hurkle? A Hurkle is a happy beast and lives in another galaxy on a planet named Lirht that has three moons. Hurkle are favorite pets of the Gwik, the dominant race of Lihrt and … well, to find out more, read “The Hurkle is a Happy Beast,” a story in the book _A Way Home_ by Theodore Sturgeon. In this program a shy hurkle is hiding on a 10 by 10 grid. Homebase is point 0,0 in the _Southwest_ corner. Your guess as to the gridpoint where the hurkle is hiding should be a pair of whole numbers, separated by a comma. After each try, the computer will tell you the approximate direction to go look for the Hurkle. You get five guesses to find him; you may change this number, although four guesses is actually enough. This program was written by Bob Albrecht of People’s Computer Company. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=94) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=109) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`52_Kinema/README.md`) ### Kinema This program tests your fundamental knowledge of kinematics. It presents a simple problem: a ball is thrown straight up into the air at some random velocity. You then must answer three questions about the flight of the ball: 1. How high will it go? 2. How long until it returns to earth? 3. What will be its velocity after a random number of seconds? The computer evaluates your performance; within 15% of the correct answer is considered close enough. After each run, the computer gives you another problem until you interrupt it. KINEMA was shorted from the original Huntington Computer Project Program, KINERV, by Richard Pav of Patchogue High School, Patchogue, New York. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=95) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=110) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`53_King/README.md`) ## King This is one of the most comprehensive, difficult, and interesting games. (If you've never played one of these games, start with HAMMURABI.) In this game, you are Premier of Setats Detinu, a small communist island 30 by 70 miles long. Your job is to decide upon the budget of your country and distribute money to your country from the communal treasury. The money system is Rollods; each person needs 100 Rallods per year to survive. Your country's income comes from farm produce and tourists visiting your magnificent forests, hunting, fishing, etc. Part of your land is farm land but it also has an excellent mineral content and may be sold to foreign industry for strip mining. Industry import and support their own workers. Crops cost between 10 and 15 Rallods per square mile to plant, cultivate, and harvest. Your goal is to complete an eight-year term of office without major mishap. A word of warning: it isn't easy! The author of this program is James A. Storer who wrote it while a student at Lexington High School. ⚠️ This game includes references to suicide or self-harm. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=96) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=111) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes Implementers should be aware that this game contains bugs. ### Bug 1 On basic line 1450 1450 V3=INT(A+V3) 1451 A=INT(A+V3) ...where A is the current treasury, and V3 is initially zero. This would mean that the treasury doubles at the end of the first year, and all calculations for an increase in the treasury due to tourism are discarded. Possibly, this made the game more playable, although impossible for the player to understand why the treasury was increasing? A quick fix for this bug in the original code would be 1450 V3=ABS(INT(V1-V2)) 1451 A=INT(A+V3) ...judging from the description of tourist income on basic line 1410 1410 PRINT " YOU MADE";ABS(INT(V1-V2));"RALLODS FROM TOURIST TRADE." ### Bug 2 On basic line 1330 following was the variable T1 never assigned: 1330 PRINT " YOU HARVESTED ";INT(J-U2);"SQ. MILES OF CROPS." 1340 IF U2=0 THEN 1370 1344 IF T1>=2 THEN 1370 1350 PRINT " (DUE TO "; 1355 IF T1=0 THEN 1365 1360 PRINT "INCREASED "; Likely it should be the difference of the current years crop loss compared to the last years crop loss. ### Bug 3 On basic line 1997 it is: 1997 PRINT " AND 10,000 SQ. MILES OF FOREST LAND." but it should be: 1997 PRINT " AND 1,000 SQ. MILES OF FOREST LAND." ### Bug 4 On basic line 1310 we see this: 1310 IF C=0 THEN 1324 1320 PRINT "OF ";INT(J);"SQ. MILES PLANTED,"; 1324 ... but it should probably be: 1310 IF J=0 THEN 1324 ### Bug 5 On basic line 1390 the income from tourism is calculated: ``` 1390 A=INT(A+Q) 1400 V1=INT(((B-P1)*22)+(RND(1)*500)) 1405 V2=INT((2000-D)*15) 1410 PRINT " YOU MADE";ABS(INT(V1-V2));"RALLODS FROM TOURIST TRADE." ``` It is very easily possible that `V2` is larger than `V1` e.g. if all of the land has been sold. In the original game this does not make a difference because of Bug 1 (see above). However, judging by how `V1` and `V2` are handled in the code, it looks like `V1` is the basic income from tourism and `V2` is a deduction for pollution. When `ABS(INT(V1-V2))` is used as earnings from tourism, the player actually _gets_ money for a large enough pollution. So a better solution would be to let `V1 - V2` cap out at 0, so once the pollution is large enough, there is no income from tourists anymore. --- ### Overview (`54_Letter/README.md`) ### Letter LETTER is similar to the game GUESS in which you guess a number chosen by the computer; in this program, the computer picks a random letter of the alphabet and you must guess which one it is using the clues provided as you go along. It should not take you more than five guesses to get the mystery letter. The program which appears here is loosely based on the original written by Bob Albrect of People’s Computer Company. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=99) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=114) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`55_Life/README.md`) ### Life The Game of Life was originally described in _Scientific American_, October 1970, in an article by Martin Gardner. The game itself was originated by John Conway of Gonville and Caius College, University of Cambridge England. In the “manual” game, organisms exist in the form of counters (chips or checkers) on a large checkerboard and die or reproduce according to some simple genetic rules. Conway’s criteria for choosing his genetic laws were carefully delineated as follows: 1. There should be no initial pattern for which there is a simple proof that the population can grow without limit. 2. There should be simple initial patterns that apparently do grow without limit. 3. There should be simple initial patterns that grow and change for a considerable period of time before coming to an end in three possible ways: 1. Fading away completely (from overcrowding or from becoming too sparse) 2. Settling into a stable configuration that remains unchanged thereafter 3. Entering an oscillating phase in which they repeat an endless cycle of two or more periods In brief, the rules should be such as to make the behavior of the population relatively unpredictable. Conway’s genetic laws are delightfully simple. First note that each cell of the checkerboard (assumed to be an infinite plane) has eight neighboring cells, four adjacent orthogonally, four adjacent diagonally. The rules are: 1. Survivals. Every counter with two or three neighboring counters survives for the next generation. 2. Deaths. Each counter with four or more neighbors dies (is removed) from overpopulation. Every counter with one neighbor or none dies from isolation. 3. Births. Each empty cell adjacent to exactly three neighbors — no more — is a birth cell. A counter is placed on it at the next move. It is important to understand that all births and deaths occur simultaneously. Together they constitute a single generation or, as we shall call it, a “move” in the complete “life history” of the initial configuration. You will find the population constantly undergoing unusual, sometimes beautiful and always unexpected change. In a few cases the society eventually dies out (all counters vanishing), although this may not happen until after a great many generations. Most starting patterns either reach stable figures — Conway calls them “still lifes” — that cannot change or patterns that oscillate forever. Patterns with no initial symmetry tend to become symmetrical. Once this happens the symmetry cannot be lost, although it may increase in richness. Conway used a DEC PDP-7 with a graphic display to observe long-lived populations. You’ll probably find this more enjoyable to watch on a CRT than a hard-copy terminal. Since MITS 8K BASIC does not have LINE INPUT, to enter leading blanks in the patter, type a “.” at the start of the line. This will be converted to a space by BASIC, but it permits you to type leading spaces. Typing DONE indicates that you are finished entering the pattern. See sample run. Clark Baker of Project DELTA originally wrote this version of LIFE which was further modified by Steve North of Creative Computing. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=100) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=115) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - To make sense of the code, it's important to understand what the values in the A(X,Y) array mean: - 0: dead cell - 1: live cell - 2: currently live, but dead next cycle - 3: currently dead, but alive next cycle (please note any difficulties or challenges in porting here) --- ### Overview (`56_Life_for_Two/README.md`) ### Life for Two LIFE-2 is based on Conway’s game of Life. You must be familiar with the rules of LIFE before attempting to play LIFE-2. There are two players; the game is played on a 5x5 board and each player has a symbol to represent his own pieces of ‘life.’ Live cells belonging to player 1 are represented by `*` and live cells belonging to player 2 are represented by the symbol `#`. The # and * are regarded as the same except when deciding whether to generate a live cell. An empty cell having two `#` and one `*` for neighbors will generate a `#`, i.e. the live cell generated belongs to the player who has the majority of the 3 live cells surrounding the empty cell where life is to be generated, for example: ``` | | 1 | 2 | 3 | 4 | 5 | |:-:|:-:|:-:|:-:|:-:|:-:| | 1 | | | | | | | 2 | | | * | | | | 3 | | | | # | | | 4 | | | # | | | | 5 | | | | | | ``` A new cell will be generated at (3,3) which will be a `#` since there are two `#` and one `*` surrounding. The board will then become: ``` | | 1 | 2 | 3 | 4 | 5 | |:-:|:-:|:-:|:-:|:-:|:-:| | 1 | | | | | | | 2 | | | | | | | 3 | | | # | # | | | 4 | | | | | | | 5 | | | | | | ``` On the first move each player positions 3 pieces of life on the board by typing in the co-ordinates of the pieces. (In the event of the same cell being chosen by both players that cell is left empty.) The board is then adjusted to the next generation and printed out. On each subsequent turn each player places one piece on the board, the object being to annihilate his opponent’s pieces. The board is adjusted for the next generation and printed out after both players have entered their new piece. The game continues until one player has no more live pieces. The computer will then print out the board and declare the winner. The idea for this game, the game itself, and the above write-up were written by Brian Wyvill of Bradford University in Yorkshire, England. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=102) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=117) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) Note: The original program has a bug. The instructions say that if both players enter the same cell that the cell is set to 0 or empty. However, the original Basic program tells the player "ILLEGAL COORDINATES" and makes another cell be entered, giving a slightly unfair advantage to the 2nd player. The Perl verson of the program fixes the bug and follows the instructions. Note: The original code had "GOTO 800" but label 800 didn't exist; it should have gone to label 999. The Basic program has been fixed. Note: The Basic program is written to assume it's being played on a Teletype, i.e. output is printed on paper. To play on a terminal the input must not be echoed, which can be a challenge to do portably and without tying the solution to a specific OS. Some versions may tell you how to do this, others might not. --- ### Overview (`57_Literature_Quiz/README.md`) ### Literature Quiz This is a simple CAI-type program which presents four multiple-choice questions from children’s literature. Running the program is self-explanatory. The program was written by Pamela McGinley while at DEC. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=104) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=117) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`58_Love/README.md`) ### Love This program is designed to reproduce Robert Indiana’s great art work “Love” with a message of your choice up to 60 characters long. The love program was created by David Ahl. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=105) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=120) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`59_Lunar_LEM_Rocket/README.md`) ### Lunar LEM Rocket This game in its many different versions and names (ROCKET, LUNAR, LEM, and APOLLO) is by far and away the single most popular computer game. It exists in various versions that start you anywhere from 500 feet to 200 miles away from the moon, or other planets, too. Some allow the control of directional stabilization rockets and/or the retro rocket. The three versions presented here represent the most popular of the many variations. In most versions of this game, the temptation is to slow up too soon and then have no fuel left for the lower part of the journey. This, of course, is disastrous (as you will find out when you land your own capsule)! LUNAR was originally in FOCAL by Jim Storer while a student at Lexington High School and subsequently converted to BASIC by David Ahl. ROCKET was written by Eric Peters at DEC and LEM by William Labaree II of Alexandria, Virginia. In this program, you set the burn rate of the retro rockets (pounds of fuel per second) every 10 seconds and attempt to achieve a soft landing on the moon. 200 lbs/sec really puts the brakes on, and 0 lbs/sec is free fall. Ignition occurs a 8 lbs/sec, so _do not_ use burn rates between 1 and 7 lbs/sec. To make the landing more of a challenge, but more closely approximate the real Apollo LEM capsule, you should make the available fuel at the start (N) equal to 16,000 lbs, and the weight of the capsule (M) equal to 32,500 lbs. #### LEM This is the most comprehensive of the three versions and permits you to control the time interval of firing, the thrust, and the attitude angle. It also allows you to work in the metric or English system of measurement. The instructions in the program dialog are very complete, so you shouldn’t have any trouble. #### ROCKET In this version, you start 500 feet above the lunar surface and control the burn rate in 1-second bursts. Each unit of fuel slows your descent by 1 ft/sec. The maximum thrust of your engine is 30 ft/sec/sec. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=106) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=121) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs ### lem.bas - The input validation on the thrust value (displayed as P, stored internally as F) appears to be incorrect. It allows negative values up up to -95, but at -96 or more balks and calls it negative. I suspect the intent was to disallow any value less than 0 (in keeping with the instructions), *or* nonzero values less than 10. - The physics calculations seem very sus. If you enter "1000,0,0" (i.e. no thrust at all, integrating 1000 seconds at a time) four times in a row, you first fall, but then mysteriously gain vertical speed, and end up being lost in space. This makes no sense. A similar result happened when just periodically applying 10% thrust in an attempt to hover. #### Porting Notes (please note any difficulties or challenges in porting here) ### LUNAR Variables: `A`: Altitude in miles. Up is positive. `V`: Velocity in miles / sec. Down is positive. `M`: Weight of capsule in pounds, both fuel and machine `N`: Empty weight of capsule in pounds. So, weight of fuel is M - N. `G`: Gravity in miles / sec^2, down is positive. `Z`: Exhaust velocity in miles / sec `L`: time in seconds since start of simulation. `K`: Burn rate for this 10 second turn, pounds of fuel per sec `T`: Time left in this 10 second turn, in seconds. `S`: Burn time in this 10 second turn, input to subroutine 420. Subroutines: 330, Apply updates from one call to subroutine 420. 370, If you started descending and ended ascending, figure out whether you hit the surface in between. 420, Compute new velocity and altitude using the Tsiolkovsky rocket equation for S seconds: `Q`: Fraction of initial mass that's burnt, i.e. 1 - mf / mo, exactly what we need for the Taylor series of `ln` in the rocket equation. Local to this subroutine. `J`: Final velocity after S seconds, down is positive. Return value. `I`: Altitude after S seconds, up is positive. Return value. --- ### Overview (`60_Mastermind/README.md`) ### MasterMind In that Match-April 1976 issue of _Creative_ we published a computerized version of Master Mind, a logic game. Master Mind is played by two people—one is called the code-maker; the other, the code-breaker. At the beginning of the game the code-maker forms a code, or combination of colored pegs. He hides these from the code-breaker. The code-breaker then attempts to deduce the code, by placing his own guesses, one at a time, on the board. After he makes a guess (by placing a combination of colored pegs on the board) the code-maker then gives the code-breaker clues to indicate how close the guess was to the code. For every peg in the guess that’s the right color but not in the right position, the code-breaker gets a white peg. Note that these black and white pegs do not indicate _which_ pegs in the guess are correct, but merely that they exist. For example, if the code was: ``` Yellow Red Red Green ``` and my guess was ``` Red Red Yellow Black ``` I would receive two white pegs and one black peg for the guess. I wouldn’t know (except by comparing previous guesses) which one of the pegs in my guess was the right color in the right position. Many people have written computer programs to play Master Mind in the passive role, i.e., the computer is the code maker and the human is the code-breaker. This is relatively trivial; the challenge is writing a program that can also play actively as a code-breaker. Actually, the task of getting the computer to deduce the correct combination is not at all difficult. Imagine, for instance, that you made a list of all possible codes. To begin, you select a guess from your list at random. Then, as you receive clues, you cross off from the list those combinations which you know are impossible. For example if your guess is Red Red Green Green and you receive no pegs, then you know that any combination containing either a red or a green peg is impossible and may be crossed of the list. The process is continued until the correct solution is reached or there are no more combinations left on the list (in which case you know that the code-maker made a mistake in giving you the clues somewhere). Note that in this particular implementation, we never actually create a list of the combinations, but merely keep track of which ones (in sequential order) may be correct. Using this system, we can easily say that the 523rd combination may be correct, but to actually produce the 523rd combination we have to count all the way from the first combination (or the previous one, if it was lower than 523). Actually, this problem could be simplified to a conversion from base 10 to base (number of colors) and then adjusting the values used in the MID$ function so as not to take a zeroth character from a string if you want to experiment. We did try a version that kept an actual list of all possible combinations (as a string array), which was significantly faster than this version, but which ate tremendous amounts of memory. At the beginning of this game, you input the number of colors and number of positions you wish to use (which will directly affect the number of combinations) and the number of rounds you wish to play. While you are playing as the code-breaker, you may type BOARD at any time to get a list of your previous guesses and clues, and QUIT to end the game. Note that this version uses string arrays, but this is merely for convenience and can easily be converted for a BASIC that has no string arrays as long as it has a MID$ function. This is because the string arrays are one-dimensional, never exceed a length greater than the number of positions and the elements never contain more than one character. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=110) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=125) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html ### How the computer deduces your guess. The computer takes the number of black pegs and white pegs that the user reports and uses that information as a target. It then assumes its guess is the answer and proceeds to compare the black and white pegs against all remaining possible answers. For each set of black and white pegs it gets in these comparisons, if they don't match what the user reported, then they can not be part of the solution. This can be a non-intuitive assumption, so we'll walk through it with a three color, three position example (27 possible solutions.) Let's just suppose our secret code we're hiding from the computer is `BWB` First let's point out the commutative property of comparing two codes for their black and white pegs. A black peg meaning correct color and correct position, and a white peg meaning correct color and wrong position. If the computer guesses `RBW` then the black/white peg report is 0 black, 2 white. But if `RBW` is the secret code and the computer guesses `BWB` the reporting for `BWB` is going to be the same, 0 black, 2 white. Now lets look at a table with the reporting for every possible guess the computer can make while our secret code is `BWB`. | Guess | Black | White | | Guess | Black | White | | Guess | Black | White | |-------|-------|-------|-----|-------|-------|-------|-----|-------|-------|-------| | BBB | 2 | 0 | | WBB | 1 | 2 | | RBB | 1 | 1 | | BBW | 1 | 2 | | WBW | 0 | 2 | | RBW | 0 | 2 | | BBR | 1 | 1 | | WBR | 0 | 2 | | RBR | 0 | 1 | | BWB | 3 | 0 | | WWB | 2 | 0 | | RWB | 2 | 0 | | BWW | 2 | 0 | | WWW | 1 | 0 | | RWW | 1 | 0 | | BWR | 2 | 0 | | WWR | 1 | 0 | | RWR | 1 | 0 | | BRB | 2 | 0 | | WRB | 1 | 1 | | RRB | 1 | 0 | | BRW | 1 | 1 | | WRW | 0 | 1 | | RRW | 0 | 1 | | BRR | 1 | 0 | | WRR | 0 | 1 | | RRR | 0 | 0 | The computer has guessed `RBW` and the report on it is 0 black, 2 white. The code used to eliminate other solutions looks like this: `1060 IF B1<>B OR W1<>W THEN I(X)=0` which says set `RBW` as the secret and compare it to all remaining solutions and get rid of any that don't match the same black and white report, 0 black and 2 white. So let's do that. Remember, `RBW` is pretending to be the secret code here. These are the remaining solutions reporting their black and white pegs against `RBW`. | Guess | Black | White | | Guess | Black | White | | Guess | Black | White | |-------|-------|-------|-----|-------|-------|-------|-----|-------|-------|-------| | BBB | 1 | 0 | | WBB | 1 | 1 | | RBB | 2 | 0 | | BBW | 2 | 0 | | WBW | 2 | 0 | | RBW | 3 | 0 | | BBR | 1 | 1 | | WBR | 1 | 2 | | RBR | 2 | 0 | | BWB | 0 | 2 | | WWB | 0 | 2 | | RWB | 1 | 2 | | BWW | 1 | 1 | | WWW | 1 | 0 | | RWW | 2 | 0 | | BWR | 0 | 3 | | WWR | 1 | 1 | | RWR | 1 | 1 | | BRB | 0 | 2 | | WRB | 0 | 3 | | RRB | 1 | 1 | | BRW | 1 | 2 | | WRW | 1 | 1 | | RRW | 2 | 0 | | BRR | 0 | 2 | | WRR | 0 | 2 | | RRR | 1 | 0 | Now we are going to eliminate every solution that **DOESN'T** match 0 black and 2 white. | Guess | Black | White | | Guess | Black | White | | Guess | Black | White | |----------|-------|-------|-----|----------|-------|-------|-----|----------|-------|-------| | ~~~BBB~~ | 1 | 0 | | ~~~WBB~~ | 1 | 1 | | ~~~RBB~~ | 2 | 0 | | ~~~BBW~~ | 2 | 0 | | ~~~WBW~~ | 2 | 0 | | ~~~RBW~~ | 3 | 0 | | ~~~BBR~~ | 1 | 1 | | ~~~WBR~~ | 1 | 2 | | ~~~RBR~~ | 2 | 0 | | BWB | 0 | 2 | | WWB | 0 | 2 | | ~~~RWB~~ | 1 | 2 | | ~~~BWW~~ | 1 | 1 | | ~~~WWW~~ | 1 | 0 | | ~~~RWW~~ | 2 | 0 | | ~~~BWR~~ | 0 | 3 | | ~~~WWR~~ | 1 | 1 | | ~~~RWR~~ | 1 | 1 | | BRB | 0 | 2 | | ~~~WRB~~ | 0 | 3 | | ~~~RRB~~ | 1 | 1 | | ~~~BRW~~ | 1 | 2 | | ~~~WRW~~ | 1 | 1 | | ~~~RRW~~ | 2 | 0 | | BRR | 0 | 2 | | WRR | 0 | 2 | | ~~~RRR~~ | 1 | 0 | That wipes out all but five solutions. Notice how the entire right column of solutions is eliminated, including our original guess of `RBW`, therefore eliminating any special case to specifically eliminate this guess from the solution set when we first find out its not the answer. Continuing on, we have the following solutions left of which our secret code, `BWB` is one of them. Remember our commutative property explained previously. | Guess | Black | White | |-------|-------|-------| | BWB | 0 | 2 | | BRB | 0 | 2 | | BRR | 0 | 2 | | WWB | 0 | 2 | | WRR | 0 | 2 | So for its second pick, the computer will randomly pick one of these remaining solutions. Let's pick the middle one, `BRR`, and perform the same ritual. Our user reports to the computer that it now has 1 black, 0 whites when comparing to our secret code `BWB`. Let's now compare `BRR` to the remaining five solutions and eliminate any that **DON'T** report 1 black and 0 whites. | Guess | Black | White | |----------|-------|-------| | BWB | 1 | 0 | | ~~~BRB~~ | 2 | 0 | | ~~~BRR~~ | 3 | 0 | | ~~~WWB~~ | 0 | 1 | | ~~~WRR~~ | 2 | 0 | Only one solution matches and it's our secret code! The computer will guess this one next as it's the only choice left, for a total of three moves. Coincidentally, I believe the expected maximum number of moves the computer will make is the number of positions plus one for the initial guess with no information. This is because it is winnowing down the solutions logarithmically on average. You noticed on the first pass, it wiped out 22 solutions. If it was doing this logarithmically the worst case guess would still eliminate 18 of the solutions leaving 9 (32). So we have as a guideline: Log(# of Colors)TotalPossibilities but TotalPossibilities = (# of Colors)# of Positions so you end up with the number of positions as a guess limit. If you consider the simplest non-trivial puzzle, two colors with two positions, and you guess BW or WB first, the most you can logically deduce if you get 1 black and 1 white is that it is either WW, or BB which could bring your total guesses up to three which is the number of positions plus one. So if your computer's turn is taking longer than the number of positions plus one to find the answer then something is wrong with your code. #### Known Bugs - Line 622 is unreachable, as the previous line ends in a GOTO and that line number is not referenced anywhere. It appears that the intent was to tell the user the correct combination after they fail to guess it in 10 tries, which would be a very nice feature, but does not actually work. (In the MiniScript port, I have made this feature work.) --- ### Overview (`61_Math_Dice/README.md`) ### Math Dice The program presents pictorial drill on addition facts using printed dice with no reading involved. It is good for beginning addition, since the answer can be derived from counting spots on the dice as well as by memorizing math facts or awareness of number concepts. It is especially effective run on a CRT terminal. It was originally written by Jim Gerrish, a teacher at the Bernice A. Ray School in Hanover, New Hampshire. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=113) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=128) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`62_Mugwump/README.md`) ### Mugwump Your objective in this game is to find the four Mugwumps hiding on various squares of a 10 by 10 grid. Homebase (lower left) is position (0,0) and a guess is a pair of whole numbers (0 to 9), separated by commas. The first number is the number of units to the right of homebase and the second number is the distance above homebase. You get ten guesses to locate the four Mugwumps; after each guess, the computer tells you how close you are to each Mugwump. Playing the game with the aid of graph paper and a compass should allow you to find all the Mugwumps in six or seven moves using triangulation similar to Loran radio navigation. If you want to make the game somewhat more difficult, you can print the distance to each Mugwump either rounded or truncated to the nearest integer. This program was modified slightly by Bob Albrecht of People’s Computer Company. It was originally written by students of Bud Valenti of Project SOLO in Pittsburg, Pennsylvania. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=114) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=129) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`63_Name/README.md`) ### Name NAME is a silly little ice-breaker to get a relationship going between a computer and a shy human. The sorting algorithm used is highly inefficient — as any reader of _Creative Computing_ will recognize, this is the worst possible sort for speed. But the program is good fun and that’s what counts here. NAME was originally written by Geoffrey Chase of the Abbey, Portsmouth, Rhode Island. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=116) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=131) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`64_Nicomachus/README.md`) ### Nicomachus One of the most ancient forms of arithmetic puzzle is sometimes referred to as a “boomerang.” At some time, everyone has been asked to “think of a number,” and, after going through some process of private calculation, to state the result, after which the questioner promptly tells you the number you originally thought of. There are hundreds of varieties of this puzzle. The oldest recorded example appears to be that given in _Arithmetica_ of Nicomachus, who died about the year 120. He tells you to think of any whole number between 1 and 100 and divide it successfully by 3, 5, and 7, telling him the remainder in each case. On receiving this information, he promptly discloses the number you thought of. Can you discover a simple method of mentally performing this feat? If not, you can see how the ancient mathematician did it by looking at this program. Nicomachus was written by David Ahl. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=117) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=132) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`65_Nim/README.md`) ### Nim NIM is one of the oldest two-person games known to man; it is believed to have originated in ancient China. The name, which was coined by the first mathematician to analyze it, comes from an archaic English verb which means to steal or to take away. Objects are arranged in rows between the two opponents as in the following example: | | | | |---------|-------|-----------| | XXXXXXX | Row 1 | 7 Objects | | XXXXX | Row 2 | 5 Objects | | XXX | Row 3 | 3 Objects | | X | Row 4 | 1 Object | Opponents take turns removing objects until there are none left. The one who picks up the last object wins. The moves are made according to the following rules: 1. On any given turn only objects from one row may be removed. There is no restriction on which row or on how many objects you remove. Of course, you cannot remove more than are in the row. 2. You cannot skip a move or remove zero objects. The winning strategy can be mathematically defined, however, rather than presenting it here, we’d rather let you find it on your own. HINT: Play a few games with the computer and mark down on a piece of paper the number of objects in each stack (in binary!) after each move. Do you see a pattern emerging? This game of NIM is from Dartmouth College and allows you to specify any starting size for the four piles and also a win option. To play traditional NIM, you would simply specify 7,5,3 and 1, and win option 1. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=118) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=133) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes This can be a real challenge to port because of all the `GOTO`s going out of loops down to code. You may need breaks and continues, or other techniques. #### Known Bugs - If, after the player moves, all piles are gone, the code prints "MACHINE LOSES" regardless of the win condition (when line 1550 jumps to line 800). This should instead jump to line 800 ("machine loses") if W=1, but jump to 820 ("machine wins") if W=2. --- ### Overview (`66_Number/README.md`) ### Number In contrast to other number guessing games where you keep guessing until you get the random number selected by the computer (GUESS, TRAP, STARS, etc.), in this game you only get one guess per play and you gain or lose points depending upon how close your guess is to the random number selected by the computer. You occasionally get a jackpot which will double your point count. You win when you get 500 points. Tom Adametx wrote this program while a student at Curtis Junior High School in Sudbury, Massachusetts. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=121) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=136) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes Contrary to the description, the computer picks *five* random numbers per turn, not one. You are not rewarded based on how close your guess is to one number, but rather to which of these five random numbers (if any) it happens to match exactly. --- ### Overview (`67_One_Check/README.md`) ### One Check In this game or puzzle, 48 checkers are placed on the two outside spaces of a standard 64-square checkerboard as shown: | | | | | | | | | |---|---|---|---|---|---|---|---| | ● | ● | ● | ● | ● | ● | ● | ● | | ● | ● | ● | ● | ● | ● | ● | ● | | ● | ● | | | | | ● | ● | | ● | ● | | | | | ● | ● | | ● | ● | | | | | ● | ● | | ● | ● | | | | | ● | ● | | ● | ● | ● | ● | ● | ● | ● | ● | | ● | ● | ● | ● | ● | ● | ● | ● | The object is to remove as many checkers as possible by diagonal jumps (as in standard checkers). It is easy to remove 30 to 39 checkers, a challenge to remove 40 to 44, and a substantial feat to remove 45 to 47. The program was created and written by David Ahl. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=122) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=137) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`68_Orbit/README.md`) ### Orbit ORBIT challenges you to visualize spacial positions in polar coordinates. The object is to detonate a Photon explosive within a certain distance of a germ laden Romulan spaceship. This ship is orbiting a planet at a constant altitude and orbital rate (degrees/hour). The location of the ship is hidden by a device that renders the ship invisible, but after each bomb you are told how close to the enemy ship your bomb exploded. The challenge is to hit an invisible moving target with a limited number of shots. The planet can be replaced by a point at its center (called the origin); then the ship’s position can be given as a distance form the origin and an angle between its position and the eastern edge of the planet. ``` direction of orbit < ^ ship \ ╱ \ ╱ < |╱ \ ╱ \ ╱ \ ╱ | angle ╱ / ╱ / ╱ / ╱——————————————————— E ``` The distance of the bomb from the ship is computed using the law of cosines. The law of cosines states: ``` D = SQUAREROOT( R**2 + D1**2 - 2*R*D1*COS(A-A1) ) ``` Where D is the distance between the ship and the bomb, R is the altitude of the ship, D1 is the altitude of the bomb, and A-A1 is the angle between the ship and the bomb. ``` bomb < ╲ ^ ship ╲ ╱ ╲ ╱ < ╲ ╱ \ D1 ╲ ╱ \ ╲ R ╱ \ ╲ A1 ╱ | A ╲⌄——— ◝╱ / ╲ ╱ \ / ╲ ╱ \ / ╲╱───────────────────── E ``` ORBIT was originally called SPACE WAR and was written by Jeff Lederer of Project SOLO Pittsburgh, Pennsylvania. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=124) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=139) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`69_Pizza/README.md`) ### Pizza In this game, you take orders for pizzas from people living in Hyattsville. Armed with a map of the city, you must then tell your delivery boy the address where the pizza is to be delivered. If the pizza is delivered to the correct address, the customer phones you and thanks you; if not, you must give the driver the correct address until the pizza gets delivered. Some interesting modifications suggest themselves for this program such as pizzas getting cold after two incorrect delivery attempts or taking three or more orders at a time and figuring out the shortest delivery route. Send us your modifications! This program seems to have surfaced originally at the University of Georgia in Athens, Georgia. The author is unknown. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=126) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=141) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - The program does no validation of its input, and crashes if you enter coordinates outside the valid range. (Ports may choose to improve on this, for example by repeating the prompt until valid coordinates are given.) #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`70_Poetry/README.md`) ### Poetry This program produces random verse which might loosely be considered in the Japanese Haiku style. It uses 20 phrases in four groups of five phrases each and generally cycles through the groups in order. It inserts commas (random — 19% of the time), indentation (random — 22% of the time), and starts new paragraphs (18% probability but at least once every 20 phrases). The phrases in POETRY are somewhat suggestive of Edgar Allen Poe. Try it with phrases from computer technology, from love and romance, from four-year-old children, or from some other project. Send us the output. Here are some phrases from nature to try: ``` Carpet of ferns Mighty Oaks Morning dew Grace and beauty Tang of dawn Silently singing Swaying pines Nature speaking Entrances me Untouched, unspoiled Soothing me Shades of green Rustling leaves Tranquility Radiates calm …so peaceful ``` The original author of this program is unknown. It was modified and reworked by Jim Bailey, Peggy Ewing, and Dave Ahl at DEC. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=128) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=143) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - The program begins by switching on `I`, which has not been initialized. We should probably initialize this to 0, though this means the output always begins with the phrase "midnight dreary". - Though the program contains an END statement (line 999), it is unreachable. The program continues to generate output until it is forcibly interrupted. --- ### Overview (`71_Poker/README.md`) ### Poker You and the computer are opponents in this game of draw poker. At the start of the game, each player is given $200. The game ends when either player runs out of money, although if you go broke the computer will offer to buy back your wristwatch or diamond tie tack. The computer opens the betting before the draw; you open the betting after the draw. If you don’t have a hand that’s worth anything and you want to fold, bet 0. Prior to the draw, to check the draw, you may bet .5. Of course, if the computer has made a bet, you must match it in order to draw or, if you have a good hand, you may raise the bet at any time. The author is A. Christopher Hall of Trinity College, Hartford, Connecticut. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=129) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=144) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - If you bet more than the computer has, it will still see you, resulting in a negative balance. (To handle this properly, the computer would need to go "all in" and reduce your bet to an amount it can match; or else lose the game, which is what happens to the human player in the same situation.) - If you are low on cash and sell your watch, then make a bet much smaller than the amount you just gained from the watch, it sometimes nonetheless tells you you "blew your wad" and ends the game. - When the watch is sold (in either direction), the buyer does not actually lose any money. - The code in the program about selling your tie tack is unreachable due to a logic bug. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`72_Queen/README.md`) ### Queen This game is based on the permissible moves of the chess queen — i.e., along any vertical, horizontal, or diagonal. In this game, the queen can only move to the left, down, and diagonally down to the left. The object of the game is to place the queen (one only) in the lower left-hand square (no. 158), by alternating moves between you and the computer. The one to place the queen there wins. You go first and place the queen in any one of the squares on the top row or the right-hand column. That is your first move. The computer is beatable, but it takes some figuring. See if you can devise a winning strategy. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=133) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=148) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`73_Reverse/README.md`) ### Reverse The game of REVERSE requires you to arrange a list of numbers in numerical order from left to right. To move, you tell the computer how many numbers (counting from the left) to reverse. For example, if the current list is: ``` 2 3 4 5 1 6 7 8 9 ``` and you reverse 4, the result will be: ``` 5 4 3 2 1 6 7 8 9 ``` Now if you reverse 5, you win! There are many ways to beat the game, but approaches tend to be either algorithmic or heuristic. The game thus offers the player a chance to play with these concepts in a practical (rather than theoretical) context. An algorithmic approach guarantees a solution in a predictable number of moves, given the number of items in the list. For example, one method guarantees a solution in 2N - 3 moves when teh list contains N numbers. The essence of an algorithmic approach is that you know in advance what your next move will be. Once could easily program a computer to do this. A heuristic approach takes advantage of “partial orderings” in the list at any moment. Using this type of approach, your next move is dependent on the way the list currently appears. This way of solving the problem does not guarantee a solution in a predictable number of moves, but if you are lucky and clever, you may come out ahead of the algorithmic solutions. One could not so easily program this method. In practice, many players adopt a “mixed” strategy, with both algorithmic and heuristic features. Is this better than either “pure” strategy? The program was created by Peter Sessions of People’s Computer Company and the notes above adapted from his original write-up. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=135) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=150) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`74_Rock_Scissors_Paper/README.md`) ### Rock, Scissors, Paper Remember the game of rock-scissors-paper. You and your opponent make a motion three times with your fists and then either show: - a flat hand (paper) - fist (rock) - two fingers (scissors) Depending upon what is shown, the game is a tie (both show the same) or one person wins. Paper wraps up rock, so it wins. Scissors cut paper, so they win. And rock breaks scissors, so it wins. In this computerized version of rock-scissors-paper, you can play up to ten games vs. the computer. Charles Lund wrote this game while at the American School in The Hague, Netherlands. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=137) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=152) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`75_Roulette/README.md`) ### Roulette This game simulates an American Roulette wheel; “American” because it has 38 number compartments (1 to 36, 0 and 00). The European wheel has 37 numbers (1 to 36 and 0). The Bahamas, Puerto Rico, and South American countries are slowly switching to the American wheel because it gives the house a bigger percentage. Odd and even numbers alternate around the wheel, as do red and black. The layout of the wheel insures a highly random number pattern. In fact, roulette wheels are sometimes used to generate tables of random numbers. In this game, you may bet from $5 to $500 and you may bet on red or black, odd or even, first or second 18 numbers, a column, or single number. You may place any number of bets on each spin of the wheel. There is no long-range winning strategy for playing roulette. However, a good strategy is that of “doubling.” First spin, bet $1 on an even/odds bet (odd, even, red, or black). If you lose, double your bet again to $2. If you lose again, double to $4. Continue to double until you win (i.e, you break even on a losing sequence). As soon as you win, bet $1 again, and after every win, bet $1. Do not ever bet more than $1 unless you are recuperating losses by doubling. Do not ever bet anything but the even odds bets. Good luck! --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=138) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=153) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - The program keeps a count of how often each number comes up in array `X`, but never makes use of this information. --- ### Overview (`76_Russian_Roulette/README.md`) ### Russian Roulette In this game, you are given by the computer a revolver loaded with one bullet and five empty chambers. You spin the chamber and pull the trigger by inputting a “1,” or, if you want to quit, input a “2.” You win if you play ten times and are still alive. Tom Adametx wrote this program while a student at Curtis Jr. High School in Sudbury, Massachusetts. ⚠️ This game includes EXPLICT references to suicide, and should not be included in most distributions, especially considering the extreme simplicity of the program. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=141) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=153) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`77_Salvo/README.md`) ### Salvo The rules are _not_ explained by the program, so read carefully this description by Larry Siegel, the program author. SALVO is played on a 10x10 grid or board using an x,y coordinate system. The player has 4 ships: - battleship (5 squares) - cruiser (3 squares) - two destroyers (2 squares each) The ships may be placed horizontally, vertically, or diagonally and must not overlap. The ships do not move during the game. As long as any square of a battleship still survives, the player is allowed three shots, for a cruiser 2 shots, and for each destroyer 1 shot. Thus, at the beginning of the game the player has 3+2+1+1=7 shots. The players enters all of his shots and the computer tells what was hit. A shot is entered by its grid coordinates, x,y. The winner is the one who sinks all of the opponents ships. Important note: Your ships are located and the computer’s ships are located on 2 _separate_ 10x10 boards. Author of the program is Lawrence Siegel of Shaker Heights, Ohio. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=142) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=157) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes The program does no validation of ship positions; your ship coordinates may be scattered around the board in any way you like. (Computer ships will not do this, but they may be placed diagonally in such a way that they cross each other.) Scattering your ships in this way probably defeats whatever all that spaghetti-code logic the computer is using to pick its moves, which is based on the assumption of contiguous ships. Moreover: as per the analysis in https://forums.raspberrypi.com/viewtopic.php?p=1997950#p1997950 see also the earlier post https://forums.raspberrypi.com/viewtopic.php?p=1994961#p1994961 in the same thread, there is a typo in later published versions of the SALVO Basic source code compared to the original edition of 101 Basic Computer Games. This typo is interesting because it causes the program to play by a much weaker strategy while exhibiting no other obvious side effects. I would recommend changing the line 3970 in the Basic program back to the original `3970 K(R,S)=K(R,S)+E(U)-2*INT(H(U)+.5)` and to change the JavaScript program accordingly. (And note that some ports — looking at you, Python — do not implement the original strategy at all, but merely pick random unshot locations for every shot.) --- ### Overview (`78_Sine_Wave/README.md`) ### Sine Wave Did you ever go to a computer show and see a bunch of CRT terminals just sitting there waiting forlornly for someone to give a demo on them. It was one of those moments when I was at DEC that I decided there should be a little bit of background activity. And why not plot with words instead of the usual X’s? Thus SINE WAVE was born and lives on in dozens of different versions. At least those CRTs don’t look so lifeless anymore. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=146) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=161) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`79_Slalom/README.md`) ### Slalom This game simulates a slalom run down a course with one to 25 gates. The user picks the number of gates and has some control over his speed down the course. If you’re not a skier, here’s your golden opportunity to try it with minimal risk. If you are a skier, here’s something to do while your leg is in a cast. SLALOM was written by J. Panek while a student at Dartmouth College. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=147) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=162) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - In the original version, the data pointer doesn't reset after a race is completed. This causes subsequent races to error at some future point at line 540, `READ Q'. - It also doesn't restore the data pointer after executing the MAX command to see the gate speeds, meaning that if you use this command, it effectively skips those gates, and the speeds shown are completely incorrect. #### Porting Notes --- ### Overview (`80_Slots/README.md`) ### Slots The slot machine or one-arm bandit is a mechanical device that will absorb coins just about as fast as you can feed it. After inserting a coin, you pull a handle that sets three independent reels spinning. If the reels stop with certain symbols appearing in the pay line, you get a certain payoff. The original slot machine, called the Liberty Bell, was invented in 1895 by Charles Fey in San Francisco. Fey refused to sell or lease the manufacturing rights, so H.S. Mills in Chicago built a similar, but much improved machine called the Operators Bell. This has survived nearly unchanged to today. On the Operators Bell and other standard slot machines, there are 20 symbols on each wheel but they are not distributed evenly among the objects (cherries, bar, apples, etc.). Of the 8,000 passible combinations, the expected payoff (to the player) is 7,049 or $89.11 for every $100.00 put in, one of the lowest expected payoffs in all casino games. In the program here, the payoff is considerably more liberal; indeed it appears to favor the player by 11% — i.e., an expected payoff of $111 for each $100 bet. The program was originally written by Fred Mirabella and Bob Harper. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=149) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=164) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Known Bugs - The original program does not correctly detect identical draws in the first and third position as a double (instead, it counts as a loss). This is probably not intended. Some of the ports fix this, so that any two matches count as a double. #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`81_Splat/README.md`) ### Splat SPLAT simulates a parachute jump in which you try to open your parachute at the last possible moment without going splat! You may select your own terminal velocity or let the computer do it for you. You many also select the acceleration due to gravity or, again, let the computer do it in which case you might wind up on any of eight planets (out to Neptune), the moon, or the sun. The computer then tells you the height you’re jumping from and asks for the seconds of free fall. It then divides your free fall time into eight intervals and gives you progress reports on your way down. The computer also keeps track of all prior jumps in the array A and lets you know how you compared with previous successful jumps. If you want to recall information from previous runs, then you should store array A in a disk or take file and read it before each run. John Yegge created this program while at the Oak Ridge Associated Universities. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=151) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=166) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`82_Stars/README.md`) ### Stars In this game, the computer selects a random number from 1 to 100 (or any value you set). You try to guess the number and the computer gives you clues to tell you how close you’re getting. One star (\*) means you’re far away from the number; seven stars (\*\*\*\*\*\*\*) means you’re really close. You get 7 guesses. On the surface this game is similar to GUESS; however, the guessing strategy is quite different. See if you can come up with one or more approaches to finding the mystery number. Bob Albrecht of People’s Computer Company created this game. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=153) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=166) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`83_Stock_Market/README.md`) ### Stock Market This program “plays” the stock market. You will be given $10,000 and may buy or sell stocks. Stock prices and trends are generated randomly; therefore, this model does not represent exactly what happens on the exchange. (Depending upon your point of view, you may feel this is quite a good representation!) Every trading day, a table of stocks, their prices, and number of shares in your portfolio is printed. Following this, the initials of each stock are printed followed by a question mark. You indicate your transaction in number of shares — a positive number to buy, negative to sell, or 0 to do no trading. A brokerage fee of 1% is charges on all transactions (a bargain!). Note: Even if the value of a stock drops to zero, it may rebound again — then again, it may not. This program was created by D. Pessel, L. Braun, and C. Losik of the Huntington Computer Project at SUNY, Stony Brook, N.Y. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=154) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=166) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`84_Super_Star_Trek/README.md`) ### Super Star Trek #### Brief History Many versions of Star Trek have been kicking around various college campuses since the late sixties. I recall playing one at Carnegie-Mellon Univ. in 1967 or 68, and a very different one at Berkeley. However, these were a far cry from the one written by Mike Mayfield of Centerline Engineering and/or Custom Data. This was written for an HP2000C and completed in October 1972. It became the “standard” Star Trek in February 1973 when it was put in the HP contributed program library and onto a number of HP Data Center machines. In the summer of 1973, I converted the HP version to BASIC-PLUS for DEC’s RSTS-11 compiler and added a few bits and pieces while I was at it. Mary Cole at DEC contributed enormously to this task too. Later that year I published it under the name SPACWR (Space War — in retrospect, an incorrect name) in my book _101 Basic Computer Games_. It is difficult today to find an interactive computer installation that does not have one of these versions of Star Trek available. #### Quadrant Nomenclature Recently, certain critics have professed confusion as to the origin on the “quadrant” nomenclature used on all standard CG (Cartesian Galactic) maps. Naturally, for anyone with the remotest knowledge of history, no explanation is necessary; however, the following synopsis should suffice for the critics: As every schoolboy knows, most of the intelligent civilizations in the Milky Way had originated galactic designations of their own choosing well before the Third Magellanic Conference, at which the so-called “2⁶ Agreement” was reached. In that historic document, the participant cultures agreed, in all two-dimensional representations of the galaxy, to specify 64 major subdivisions, ordered as an 8 x 8 matrix. This was partially in deference to the Earth culture (which had done much in the initial organization of the Federation), whose century-old galactic maps had always shown 16 major regions named after celestial landmarks divided into four “quadrants,” designated by ancient “Roman Numerals” (the origin of which has been lost). To this day, the official logs of starships originating on near-Earth starbases still refer to the major galactic areas as “quadrants.” The relation between the Historical and Standard nomenclatures is shown in the simplified CG map below. | | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | |---|--------------|----|-----|----|------------|----|-----|----| | 1 | ANTARES | | | | SIRIUS | | | | | | I | II | III | IV | I | II | III | IV | | 2 | RIGEL | | | | DENEB | | | | | | I | II | III | IV | I | II | III | IV | | 3 | PROCYON | | | | CAPELLA | | | | | | I | II | III | IV | I | II | III | IV | | 4 | VEGA | | | | BETELGUESE | | | | | | I | II | III | IV | I | II | III | IV | | 5 | CANOPUS | | | | ALDEBARA | | | | | | I | II | III | IV | I | II | III | IV | | 6 | ALTAIR | | | | REGULUS | | | | | | I | II | III | IV | I | II | III | IV | | 7 | SAGITTARIOUS | | | | ARCTURUS | | | | | | I | II | III | IV | I | II | III | IV | | 8 | POLLUX | | | | SPICA | | | | | | I | II | III | IV | I | II | III | IV | #### Super Star Trek† Rules and Notes 1. OBJECTIVE: You are Captain of the starship “Enterprise”† with a mission to seek and destroy a fleet of Klingon† warships (usually about 17) which are menacing the United Federation of Planets.† You have a specified number of stardates in which to complete your mission. You also have two or three Federation Starbases† for resupplying your ship. 2. You will be assigned a starting position somewhere in the galaxy. The galaxy is divided into an 8 x 8 quadrant grid. The astronomical name of a quadrant is called out upon entry into a new region. (See “Quadrant Nomenclature.”) Each quadrant is further divided into an 8 x 8 section grid. 3. On a section diagram, the following symbols are used: - `<*>` Enterprise - `†††` Klingon - `>!<` Starbase - `*` Star 4. You have eight commands available to you (A detailed description of each command is given in the program instructions.) - `NAV` Navigate the Starship by setting course and warp engine speed. - `SRS` Short-range sensor scan (one quadrant) - `LRS` Long-range sensor scan (9 quadrants) - `PHA` Phaser† control (energy gun) - `TOR` Photon torpedo control - `SHE` Shield control (protects against phaser fire) - `DAM` Damage and state-of-repair report - `COM` Call library computer 5. Library computer options are as follows (more complete descriptions are in program instructions): - `0` Cumulative galactic report - `1` Status report - `2` Photon torpedo course data - `3` Starbase navigation data - `4` Direction/distance calculator - `5` Quadrant nomenclature map 6. Certain reports on the ship’s status are made by officers of the Enterprise who appears on the original TV Show—Spock,† Scott,† Uhura,† Chekov,† etc. 7. Klingons are non-stationary within their quadrants. If you try to maneuver on them, they will move and fire on you. 8. Firing and damage notes: - Phaser fire diminishes with increased distance between combatants. - If a Klingon zaps you hard enough (relative to your shield strength) he will generally cause damage to some part of your ship with an appropriate “Damage Control” report resulting. - If you don’t zap a Klingon hard enough (relative to his shield strength) you won’t damage him at all. Your sensors will tell the story. - Damage control will let you know when out-of-commission devices have been completely repaired. 9. Your engines will automatically shut down if you should attempt to leave the galaxy, or if you should try to maneuver through a star, or Starbase, or—heaven help you—a Klingon warship. 10. In a pinch, or if you should miscalculate slightly, some shield control energy will be automatically diverted to warp engine control (if your shield are operational!). 11. While you’re docked at a Starbase, a team of technicians can repair your ship (if you’re willing for them to spend the time required—and the repairmen _always_ underestimate…) 12. If, to same maneuvering time toward the end of the game, you should cold-bloodedly destroy a Starbase, you get a nasty note from Starfleet Command. If you destroy your _last_ Starbase, you lose the game! (For those who think this is too a harsh penalty, delete line 5360-5390, and you’ll just get a “you dumdum!”-type message on all future status reports.) 13. End game logic has been “cleaned up” in several spots, and it is possible to get a new command after successfully completing your mission (or, after resigning your old one). 14. For those of you with certain types of CRT/keyboards setups (e.g. Westinghouse 1600), a “bell” character is inserted at appropriate spots to cause the following items to flash on and off on the screen: - The Phrase “\*RED\*” (as in Condition: Red) - The character representing your present quadrant in the cumulative galactic record printout. 15. This version of Star Trek was created for a Data General Nova 800 system with 32K or core. So that it would fit, the instructions are separated from the main program via a CHAIN. For conversion to DEC BASIC-PLUS, Statement 160 (Randomize) should be moved after the return from the chained instructions, say to Statement 245. For Altair BASIC, Randomize and the chain instructions should be eliminated. † Designates trademark of Paramount Pictures Corporation. Used by permission of Paramount Pictures Corporation. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=157) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=172) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html Instructions in this directory at instructions.txt #### Porting Notes Many of the programs in this book and this collection have bugs in the original code. @jkboyce has done a great job of discovering and fixing a number of bugs in the [original code](superstartrek.bas), as part of his [python implementation](python/superstartrek.py), which should be noted by other implementers: - line `4410` : `D(7)` should be `D(6)` - lines `8310`,`8330`,`8430`,`8450` : Division by zero is possible - line `440` : `B9` should be initialised to 0, not 2 #### External Links - C++: https://www.codeproject.com/Articles/28399/The-Object-Oriented-Text-Star-Trek-Game-in-C --- ### Overview (`85_Synonym/README.md`) ### Synonym A synonym of a word is another word (in the English language) which has the same, or very nearly the same, meaning. This program tests your knowledge of synonyms of a few common words. The computer chooses a word and asks you for a synonym. The computer then tells you whether you’re right or wrong. If you can’t think of a synonym, type “HELP” which causes a synonym to be printed. You may put in words of your choice in the data statements. The number following DATA in Statement 500 is the total number of data statements. In each data statement, the first number is the number of words in that statement. Can you think of a way to make this into a more general kind of CAI program for any subject? Walt Koetke of Lexington High School, Massachusetts created this program. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=164) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=179) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes - Each time the player asks for HELP, one of the synonyms is shown and discarded. There is no protection against the player using up all of the help. - The player can ask for HELP and then submit that answer. Is it meant to be a clue, or just giving a correct answer to the player? --- ### Overview (`86_Target/README.md`) ### Target In this program, you are firing a weapon from a spaceship in 3-dimensional space. Your ship, the Starship Enterprise, is located at the origin (0,0,0) of a set of x,y,z coordinates. You will be told the approximate location of the target in 3-dimensional rectangular coordinates, the approximate angular deviation from the x and z axes in both radians and degrees, and the approximate distance to the target. Given this information, you then proceed to shoot at the target. A shot within 20 kilometers of the target destroys it. After each shot, you are given information as to the position of the explosion of your shot and a somewhat improved estimate of the location of the target. Fortunately, this is just practice and the target doesn’t shoot back. After you have attained proficiency, you ought to be able to destroy a target in 3 or 4 shots. However, attaining proficiency might take a while! The author is H. David Crockett of Fort Worth, Texas. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=165) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=180) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`87_3-D_Plot/README.md`) ### 3-D Plot 3-D PLOT will plot the family of curves of any function. The function Z is plotted as “rising” out of the x-y plane with x and y inside a circle of radius 30. The resultant plot looks almost 3-dimensional. You set the function you want plotted in line 5. As with any mathematical plot, some functions come out “prettier” than others. The author of this amazingly clever program is Mark Bramhall of DEC. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=167) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=182) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`88_3-D_Tic-Tac-Toe/README.md`) ### 3-D Tic-Tac-Toe 3-D TIC-TAC-TOE is a game of tic-tac-toe in a 4x4x4 cube. You must get 4 markers in a row or diagonal along any 3-dimensional plane in order to win. Each move is indicated by a 3-digit number (digits not separated by commas), with each digit between 1 and 4 inclusive. The digits indicate the level, column, and row, respectively, of the move. You can win if you play correctly; although, it is considerably more difficult than standard, two-dimensional 3x3 tic-tac-toe. This version of 3-D TIC-TAC-TOE is from Dartmouth College. ### Conversion notes The AI code for TicTacToe2 depends quite heavily on the non-structured GOTO (I can almost hear Dijkstra now) and translation is quite challenging. This code relies very heavily on GOTOs that bind the code tightly together. Comments explain where that happens in the original. There are at least two bugs from the original BASIC: 1. Code should only allow player to input valid 3D coordinates where every digit is between 1 and 4, but the original code allows any value between 111 and 444 (such as 297, for instance). 2. If the player moves first and the game ends in a draw, the original program will still prompt the player for a move instead of calling for a draw. Also note that while the file is called qubit.bas (with a "T"), the title shown in the program listing is "QUBIC" (with "C")... and the sample output shows "TIC TAC TOE" instead of either of these. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=168) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=183) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`89_Tic-Tac-Toe/README.md`) ### Tic-Tac-Toe The game of tic-tac-toe hardly needs any introduction. In this one, you play versus the computer. Moves are entered by number: ``` 1 2 3 4 5 6 7 8 9 ``` If you make any bad moves, the computer will win; if the computer makes a bad move, you can win; otherwise, the game ends in a tie. A second version of the game is included which prints out the board after each move. This is ideally suited to a CRT terminal, particularly if you modify it to not print out a new board after each move, but rather use the cursor to make the move. The first program was written by Tom Koos while a student researcher at the Oregon Museum of Science and Industry; it was extensively modified by Steve North of Creative Computing. The author of the second game is Curt Flick of Akron, Ohio. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=171) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=186) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`90_Tower/README.md`) ### Tower This is a simulation of a game of logic that originated in the middle East. It is sometimes called Pharaoh's Needles, but its most common name is the Towers of Hanoi. Legend has it that a secret society of monks live beneath the city of Hanoi. They possess three large towers or needles on which different size gold disks may be placed. Moving one at a time and never placing a large on a smaller disk, the monks endeavor to move the tower of disks from the left needle to the right needle. Legend says when they have finished moving this 64-disk tower, the world will end. How many moves will they have to make to accomplish this? If they can move 1 disk per minute and work 24 hours per day, how many years will it take? In the computer puzzle you are faced with three upright needles. On the leftmost needle are placed from two to seven graduated disks, the largest being on bottom and smallest on top. Your object is to move the entire stack of disks to the rightmost needle. However, you many only move one disk at a time and you may never place a larger disk on top of a smaller one. In this computer game, the disks are referred to by their size — i.e., the smallest is 3, next 5, 7, 9, 11, 13, and 15. If you play with fewer than 7 disks always use the largest, i.e. with 2 disks you would use nos. 13 and 15. The program instructions are self-explanatory. Good luck! Charles Lund wrote this program while at the American School in the Hague, Netherlands. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=173) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=188) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`91_Train/README.md`) ### Train TRAIN is a program which uses the computer to generate problems with random initial conditions to teach about the time-speed-distance relationship (distance = rate x time). You then input your answer and the computer verifies your response. TRAIN is merely an example of a student-generated problem. Maximum fun (and benefit) comes more from _writing_ programs like this as opposed to solving the specific problem posed. Exchange your program with others—you solve their problem and let them solve yours. TRAIN was originally written in FOCAL by one student for use by others in his class. It was submitted to us by Walt Koetke, Lexington High School, Lexington, Mass. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=175) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=190) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`92_Trap/README.md`) ### Trap This is another in the family of “guess the mystery number” games. In TRAP the computer selects a random number between 1 and 100 (or other limit set). Your object is to find the number. On each guess, you enter 2 numbers trying to trap the mystery number between your two trap numbers. The computer will tell you if you have trapped the number. To win the game, you must guess the mystery number by entering it as the same value for both of your trap numbers. You get 6 guesses (this should be changed if you change the guessing limit). After you have played GUESS, STARS, and TRAP, compare the guessing strategy you have found best for each game. Do you notice any similarities? What are the differences? Can you write a new guessing game with still another approach? TRAP was suggested by a 10-year-old when he was playing GUESS. It was originally programmed by Steve Ullman and extensively modified into its final form by Bob Albrecht of People’s Computer Co. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=176) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=191) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`93_23_Matches/README.md`) ### 23 Matches In the game of twenty-three matches, you start with 23 matches lying on a table. On each turn, you may take 1, 2, or 3 matches. You alternate moves with the computer and the one who has to take the last match loses. The easiest way to devise a winning strategy is to start at the end of the game. Since your wish to leave the last match to your opponent, you would like to have either 4, 3, or 2 on your last turn you so can take away 3, 2, or 1 and leave 1. Consequently, you would like to leave your opponent with 5 on his next to last turn so, no matter what his move, you are left with 4, 3, or 2. Work this backwards to the beginning and you’ll find the game can effectively be won on the first move. Fortunately, the computer gives you the first move, so if you play wisely, you can win. After you’ve mastered 23 Matches, move on to BATNUM and then to NUM. This version of 23 Matches was originally written by Bob Albrecht of People’s Computer Company. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=177) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=192) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes There is an oddity (you can call it a bug, but it is no big deal) in the original code. If there are only two or three matches left at the player's turn and the player picks all of them (or more), the game would still register that as a win for the player. --- ### Overview (`94_War/README.md`) ### War This program plays the card game of War. In War, the card deck is shuffled, then two cards are dealt, one to each player. Players compare cards and the higher card (numerically) wins. In case of a tie, no one wins. The game ends when you have gone through the whole deck (52 cards, 26 games) or when you decide to quit. The computer gives cards by suit and number, for example, S-7 is the 7 of spades. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=178) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=193) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`95_Weekday/README.md`) ### Weekday This program gives facts about your date of birth (or some other day of interest). It is not prepared to give information on people born before the use of the current type of calendar, i.e. year 1582. You merely enter today’s date in the form—month, day, year and your date of birth in the same form. The computer then tells you the day of the week of your birth date, your age, and how much time you have spent sleeping, eating, working, and relaxing. This program was adapted from a GE timesharing program by Tom Kloos at the Oregon Museum of Science and Industry. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=179) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=194) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`96_Word/README.md`) ### Word WORD is a combination of HANGMAN and BAGELS. In this game, the player must guess a word with clues as to a letter position furnished by the computer. However, instead of guessing one letter at a time, in WORD you guess an entire word (or group of 5 letters, such as ABCDE). The computer will tell you if any letters that you have guessed are in the mystery word and if any of them are in the correct position. Armed with these clues, you go on guessing until you get the word or, if you can’t get it, input a “?” and the computer will tell you the mystery word. You may change the words in Data Statements, but they must be 5-letter words. The author of this program is Charles Reid of Lexington High School, Lexington, Massachusetts. --- As published in Basic Computer Games (1978): - [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=181) - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=194) Downloaded from Vintage Basic at http://www.vintage-basic.net/games.html #### Porting Notes (please note any difficulties or challenges in porting here) --- ### Overview (`00_Alternate_Languages/01_Acey_Ducey/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. #### External Links - Common Lisp: https://github.com/koalahedron/lisp-computer-games/blob/master/01%20Acey%20Ducey/common-lisp/acey-deucy.lisp - PowerShell: https://github.com/eweilnau/basic-computer-games-powershell/blob/main/AceyDucey.ps1 --- ### Overview (`00_Alternate_Languages/02_Amazing/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/03_Animal/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/04_Awari/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/05_Bagels/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/06_Banner/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/07_Basketball/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/08_Batnum/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/09_Battle/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/10_Blackjack/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/11_Bombardment/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/12_Bombs_Away/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/13_Bounce/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/14_Bowling/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/15_Boxing/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/16_Bug/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/17_Bullfight/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/18_Bullseye/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/19_Bunny/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/20_Buzzword/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/21_Calendar/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/22_Change/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/23_Checkers/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/24_Chemist/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/25_Chief/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/26_Chomp/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/27_Civil_War/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/28_Combat/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/29_Craps/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/30_Cube/README.md`) #### External Links - Common Lisp: https://github.com/koalahedron/lisp-computer-games/blob/master/01%20Acey%20Ducey/common-lisp/acey-deucy.lisp - PowerShell: https://github.com/eweilnau/basic-computer-games-powershell/blob/main/AceyDucey.ps1 --- ### Overview (`00_Alternate_Languages/31_Depth_Charge/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/32_Diamond/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/33_Dice/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/34_Digits/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/35_Even_Wins/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/36_Flip_Flop/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/37_Football/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/38_Fur_Trader/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/39_Golf/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/40_Gomoko/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/41_Guess/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/42_Gunner/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/43_Hammurabi/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/44_Hangman/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/45_Hello/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/46_Hexapawn/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/47_Hi-Lo/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/48_High_IQ/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/49_Hockey/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/50_Horserace/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/51_Hurkle/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/52_Kinema/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/53_King/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/54_Letter/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/55_Life/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/56_Life_for_Two/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/57_Literature_Quiz/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/58_Love/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/59_Lunar_LEM_Rocket/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/60_Mastermind/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/61_Math_Dice/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/62_Mugwump/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/63_Name/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/64_Nicomachus/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/65_Nim/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/66_Number/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/67_One_Check/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/68_Orbit/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/69_Pizza/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/70_Poetry/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/71_Poker/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/72_Queen/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/73_Reverse/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/74_Rock_Scissors_Paper/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/75_Roulette/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/76_Russian_Roulette/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/77_Salvo/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/78_Sine_Wave/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/79_Slalom/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/80_Slots/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/81_Splat/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/82_Stars/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/83_Stock_Market/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/84_Super_Star_Trek/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/85_Synonym/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/86_Target/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/87_3-D_Plot/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/88_3-D_Tic-Tac-Toe/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/89_Tic-Tac-Toe/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/90_Tower/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/91_Train/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/92_Trap/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/93_23_Matches/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/94_War/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/95_Weekday/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Alternate_Languages/96_Word/README.md`) Please refer to the `readme.md` in the parent folder. Each subfolder represents a port of this program to a language which is _not_ one of the agreed upon 10 languages, which are intended to meet these three criteria: 1. Popular (by TIOBE index) 2. Memory safe 3. Generally considered a 'scripting' language We welcome additional ports, but these additional ports are for educational purposes only. --- ### Overview (`00_Common/dotnet/README.md`) # Games.Common This is the common library for C# and VB.Net ports of the games. ## Overview ### Game Input/Output * `TextIO` is the main class which manages text input and output for a game. It take a `TextReader` and a `TextWriter` in its constructor so it can be wired up in unit tests to test gameplay scenarios. * `ConsoleIO` derives from `TextIO` and binds it to `System.Console.In` and `System.Console.Out`. * `IReadWrite` is an interface implemented by `TextIO` which may be useful in some test scenarios. ```csharp public interface IReadWrite { // Reads a float value from input. float ReadNumber(string prompt); // Reads 2 float values from input. (float, float) Read2Numbers(string prompt); // Reads 3 float values from input. (float, float, float) Read3Numbers(string prompt); // Reads 4 float values from input. (float, float, float, float) Read4Numbers(string prompt); // Read numbers from input to fill an array. void ReadNumbers(string prompt, float[] values); // Reads a string value from input. string ReadString(string prompt); // Reads 2 string values from input. (string, string) Read2Strings(string prompt); // Writes a string to output. void Write(string message); // Writes a string to output, followed by a new-line. void WriteLine(string message = ""); // Writes a float to output, formatted per the BASIC interpreter, with leading and trailing spaces. void Write(float value); // Writes a float to output, formatted per the BASIC interpreter, with leading and trailing spaces, // followed by a new-line. void WriteLine(float value); // Writes the contents of a Stream to output. void Write(Stream stream);} ``` ### Random Number Generation * `IRandom` is an interface that provides basic methods that parallel the 3 uses of BASIC's `RND(float)` function. * `RandomNumberGenerator` is an implementation of `IRandom` built around `System.Random`. * `IRandomExtensions` provides convenience extension methods for obtaining random numbers as `int` and also within a given range. ```csharp public interface IRandom { // Like RND(1), gets a random float such that 0 <= n < 1. float NextFloat(); // Like RND(0), Gets the float returned by the previous call to NextFloat. float PreviousFloat(); // Like RND(-x), Reseeds the random number generator. void Reseed(int seed); } ``` Extension methods on `IRandom`: ```csharp // Gets a random float such that 0 <= n < exclusiveMaximum. float NextFloat(this IRandom random, float exclusiveMaximum); // Gets a random float such that inclusiveMinimum <= n < exclusiveMaximum. float NextFloat(this IRandom random, float inclusiveMinimum, float exclusiveMaximum); // Gets a random int such that 0 <= n < exclusiveMaximum. int Next(this IRandom random, int exclusiveMaximum); // Gets a random int such that inclusiveMinimum <= n < exclusiveMaximum. int Next(this IRandom random, int inclusiveMinimum, int exclusiveMaximum); // Gets the previous unscaled float (between 0 and 1) scaled to a new range: // 0 <= x < exclusiveMaximum. float PreviousFloat(this IRandom random, float exclusiveMaximum); // Gets the previous unscaled float (between 0 and 1) scaled to a new range: // inclusiveMinimum <= n < exclusiveMaximum. float PreviousFloat(this IRandom random, float inclusiveMinimum, float exclusiveMaximum); // Gets the previous unscaled float (between 0 and 1) scaled to an int in a new range: // 0 <= n < exclusiveMaximum. int Previous(this IRandom random, int exclusiveMaximum); // Gets the previous unscaled float (between 0 and 1) scaled to an int in a new range: // inclusiveMinimum <= n < exclusiveMaximum. int Previous(this IRandom random, int inclusiveMinimum, int exclusiveMaximum); ``` ## C\# Usage ### Add Project Reference Add the `Games.Common` project as a reference to the game project. For example, here's the reference from the C\# port of `86_Target`: ```xml ``` ### C# Game Input/Output usage A game can be encapsulated in a class which takes a `TextIO` instance in it's constructor: ```csharp public class Game { private readonly TextIO _io; public Game(TextIO io) => _io = io; public void Play() { var name = _io.ReadString("What is your name"); var (cats, dogs) = _io.Read2Number($"Hello, {name}, how many pets do you have (cats, dogs)"); _io.WriteLine($"So, {cats + dogs} pets in total, huh?"); } } ``` Then the entry point of the game program would look something like: ```csharp var game = new Game(new ConsoleIO()); game.Play(); ``` ### C# Random Number Generator usage ```csharp var io = new ConsoleIO(); var rng = new RandomNumberGenerator(); io.WriteLine(rng.NextFloat()); // 0.1234, for example io.WriteLine(rng.NextFloat()); // 0.6, for example io.WriteLine(rng.PreviousFloat()); // 0.6, repeats previous io.WriteLine(rng.PreviousFloat(0, 10)); // 6, repeats previous value, but scaled to new range ``` ### C# Unit Test usage `TextIO` can be initialised with a `StringReader` and `StringWriter` to enable testing. For example, given the `Game` class above: ```csharp var reader = new StringReader("Joe Bloggs\r\n4\n\r5"); var writer = new StringWriter(); var game = new Game(new TextIO(reader, writer)) game.Play(); writer.ToString().Should().BeEquivalentTo( "What is your name? Hello, Joe Bloggs, how many pets do you have (cats, dogs)? ?? So, 9 pets in total, huh?"); ``` Note the lack of line breaks in the expected output, because during game play the line breaks come from the text input. Of course, `IReadWrite` can also be mocked for simple test scenarios. ## VB.Net Usage *To be provided* --- ### Overview (`01_Acey_Ducey/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) by Adam Dawes (@AdamDawes575, https://adamdawes.com). --- ### Overview (`01_Acey_Ducey/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) Two versions of Acey Ducey have been contributed. The original upload supported JDK 8/JDK 11 and uses multiple files and the second uses features in JDK 17 and is implemented in a single file AceyDucey17.java. Both are in the src folder. --- ### Overview (`01_Acey_Ducey/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`01_Acey_Ducey/lua/README.md`) As published in Basic Computer Games (1978), as found at Annarchive: - [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=17) Conversion to Lua - [Lua.org](https://www.lua.org) --- ### Overview (`01_Acey_Ducey/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`01_Acey_Ducey/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) Propose using pylint and black to format python files so that it conforms to some standards --- ### Overview (`01_Acey_Ducey/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) by Christopher Özbek [coezbek@github](https://github.com/coezbek). --- ### Overview (`01_Acey_Ducey/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Alex Kotov [mur4ik18@github](https://github.com/mur4ik18). Further edits by - Berker Şal [berkersal@github](https://github.com/berkersal) --- ### Overview (`01_Acey_Ducey/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`02_Amazing/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`02_Amazing/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`02_Amazing/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`02_Amazing/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`02_Amazing/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`02_Amazing/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`02_Amazing/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`02_Amazing/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) Converted to Ruby (with tons of inspiration from the Python version) by @marcheiligers Run `ruby amazing.rb`. Run `DEBUG=1 ruby amazing.ruby` to see how it works (requires at least Ruby 2.7). --- ### Overview (`02_Amazing/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`02_Amazing/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`03_Animal/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`03_Animal/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`03_Animal/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`03_Animal/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`03_Animal/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`03_Animal/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`03_Animal/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`03_Animal/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`03_Animal/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by [Anton Kaiukov](https://github.com/batk0) --- ### Overview (`03_Animal/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) This takes some inspiration from the [C# port of Animal](https://github.com/zspitz/basic-computer-games/tree/main/03_Animal/csharp). The `Game` class takes a console abstraction (`ConsoleAdapterBase`), which could also be used for different UIs, such as WinForms or a web page. This solution also has an xUnit tests project. Responses can be entered in any capitalization, but animals and the distinguishing question will be converted to uppercase. --- ### Overview (`04_Awari/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`04_Awari/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`04_Awari/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`04_Awari/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`04_Awari/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`04_Awari/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`04_Awari/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`04_Awari/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) by [Alex Scown](https://github.com/TheScown) --- ### Overview (`04_Awari/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`05_Bagels/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`05_Bagels/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`05_Bagels/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`05_Bagels/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`05_Bagels/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`05_Bagels/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`05_Bagels/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`05_Bagels/ruby/README.md`) ## BAGELS Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) by [Tom Armitage](https://github.com/infovore) ## Translator's notes: This is a highly imperative port. As such, it's very much, in the spirit of David Ahl's original version, and also highly un-Rubyish. A few decisions I made: * the main loop is a 'while' loop. Most games are a main loop that runs until it doesn't, and I felt that "while the player wished to keep playing, the game should run" was an appropriate structure. * lots of puts and gets; that feels appropriate to the Ahl implementation. No clever cli or curses libraries here. * the number in question, and the player's answer, are stored as numbers. They're only converted into arrays for the purpose of `puts_clue_for` - ie, when comparison is need. The original game stored them as arrays, which made sense, but given the computer says "I have a number in mind", I decided to store what was in its 'mind' as a number. * the `String#center` method from Ruby 2.5~ sure is handy. --- ### Overview (`05_Bagels/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Till Klister [tikste@github](https://github.com/tikste). --- ### Overview (`05_Bagels/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`06_Banner/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`06_Banner/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`06_Banner/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`06_Banner/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`06_Banner/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`06_Banner/pascal/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) --- ### Overview (`06_Banner/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`06_Banner/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`06_Banner/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`06_Banner/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`07_Basketball/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`07_Basketball/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`07_Basketball/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`07_Basketball/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`07_Basketball/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`07_Basketball/pascal/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) --- ### Overview (`07_Basketball/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) There are two version of the code here, a "faithful" translation (basketball-orig.pl) and a "modern" translation (basketball.pl). The main difference between the 2 are is that the faithful translation has 3 GOTOs in it while the modern version has no GOTO. I have added a "TIME" print when the score is shown so the Clock is visible. Halftime is at "50" and end of game is at 100 (per the Basic code). The 3 GOTOs in the faitful version are because of the way the original code jumped into the "middle of logic" that has no obivious way to avoid ... that I can see, at least while still maintaining something of the look and structure of the original Basic. The modern version avoided the GOTOs by restructuring the program in the 2 "play()" subs. Despite the change, this should play the same way as the faithful version. All of the percentages remain the same. If writing this from scratch, we really should have only a single play() sub which uses the same code for both teams, which would also make the game more fair ... but that wasn't done so the percent edge to Darmouth has been maintained here. --- ### Overview (`07_Basketball/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`07_Basketball/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`07_Basketball/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`08_Batnum/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) This conversion uses C#9 and is built for .net 5.0 Functional changes from Original - handle edge condition for end game where the minimum draw amount is greater than the number of items remaining in the pile - Takes into account the width of the console - Mulilingual Support (English/French currently) --- ### Overview (`08_Batnum/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`08_Batnum/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`08_Batnum/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`08_Batnum/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`08_Batnum/pascal/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) --- ### Overview (`08_Batnum/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) by [Austin White](https://github.com/austinwhite) --- ### Overview (`08_Batnum/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`08_Batnum/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`08_Batnum/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`09_Battle/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`09_Battle/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`09_Battle/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`09_Battle/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`09_Battle/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`09_Battle/pascal/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) --- ### Overview (`09_Battle/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`09_Battle/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`09_Battle/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`09_Battle/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`10_Blackjack/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`10_Blackjack/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`10_Blackjack/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`10_Blackjack/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`10_Blackjack/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`10_Blackjack/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`10_Blackjack/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`10_Blackjack/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`10_Blackjack/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`10_Blackjack/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`11_Bombardment/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`11_Bombardment/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`11_Bombardment/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`11_Bombardment/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`11_Bombardment/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`11_Bombardment/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`11_Bombardment/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`11_Bombardment/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`11_Bombardment/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by [ugurkupeli](https://github.com/ugurkupeli) --- ### Overview (`11_Bombardment/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`12_Bombs_Away/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`12_Bombs_Away/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`12_Bombs_Away/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`12_Bombs_Away/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`12_Bombs_Away/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`12_Bombs_Away/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`12_Bombs_Away/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`12_Bombs_Away/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`12_Bombs_Away/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`13_Bounce/csharp/README.md`) # Bounce Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) ## Conversion notes ### Mode of Operation This conversion performs the same function as the original, and provides the same experience, but does it in a different way. The original BASIC code builds the graph as it writes to the screen, scanning each line for points that need to be plotted. This conversion steps through time, calculating the position of the ball at each instant, building the graph in memory. It then writes the graph to the output in one go. ### Failure Modes The original BASIC code performs no validation of the input parameters. Some combinations of parameters produce no output, others crash the program. In the spirit of the original this conversion also performs no validation of the parameters, but it does not attempt to replicate the original's failure modes. It fails quite happily in its own way. --- ### Overview (`13_Bounce/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`13_Bounce/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`13_Bounce/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`13_Bounce/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`13_Bounce/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) Added feature so that if "TIME" value is "0" then it will quit, so you don't have to hit Control-C. Also added a little error checking of the input. --- ### Overview (`13_Bounce/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`13_Bounce/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`13_Bounce/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`14_Bowling/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`14_Bowling/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`14_Bowling/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`14_Bowling/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`14_Bowling/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`14_Bowling/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) ###Bowling program in Perl Run normally, this is a fairly faithful translation of the Basic game. The only real differences are a few trivial fix-ups on the prints to make it look better, and the player/frame/ball line was put before the "get the ball going" line to make it more obvious who's turn it is. However, if you run it with "-a" on the command line, it will go into "advanced" mode, which means that "." is used to show pin down and "!" for pin up, current running scores are shown at the end of each frame, and the scoring also looks more normal at the end. This is all done because I think it looks better and I wanted to see a score. Having a flag says you can play whichever version of the game you like. Note, the original code doesn't do the 10th frame correctly, in that it will never do more than 2 balls, so the best score you can get is a 290. This is true in both modes. That being said, it will always give you a mediocre game; I don't think I've ever seen a score over 140. --- ### Overview (`14_Bowling/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`14_Bowling/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`14_Bowling/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`15_Boxing/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`15_Boxing/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`15_Boxing/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`15_Boxing/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`15_Boxing/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`15_Boxing/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`15_Boxing/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`15_Boxing/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`15_Boxing/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`16_Bug/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`16_Bug/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`16_Bug/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`16_Bug/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`16_Bug/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`16_Bug/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`16_Bug/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`16_Bug/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`16_Bug/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`17_Bullfight/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`17_Bullfight/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`17_Bullfight/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`17_Bullfight/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`17_Bullfight/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`17_Bullfight/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`17_Bullfight/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`17_Bullfight/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`17_Bullfight/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`18_Bullseye/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`18_Bullseye/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`18_Bullseye/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`18_Bullseye/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`18_Bullseye/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`18_Bullseye/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`18_Bullseye/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`18_Bullseye/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`18_Bullseye/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`18_Bullseye/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`19_Bunny/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`19_Bunny/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`19_Bunny/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`19_Bunny/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`19_Bunny/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`19_Bunny/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`19_Bunny/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`19_Bunny/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) There are two versions of this program here: * `bunny-faithful.rb` tries to be faithful to the design of the original BASIC program. * `bunny-modern.rb` takes more advantage of the features of modern tools and languages. --- ### Overview (`19_Bunny/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`20_Buzzword/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`20_Buzzword/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`20_Buzzword/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`20_Buzzword/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`20_Buzzword/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`20_Buzzword/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`20_Buzzword/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`20_Buzzword/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`20_Buzzword/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`20_Buzzword/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`21_Calendar/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`21_Calendar/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`21_Calendar/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`21_Calendar/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`21_Calendar/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`21_Calendar/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) Actually, this is not so much a port as a complete rewrite, making use of Perl's Posix time functionality. The calendar is for the current year (not 1979), but you can get another year by specifying it on the command line, e.g. `perl 21_Calendar/perl/calendar.pl 2001` It *may* even produce output in languages other than English. But the leftmost column will still be Sunday, even in locales where it is typically Monday. --- ### Overview (`21_Calendar/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`21_Calendar/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`21_Calendar/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by [Uğur Küpeli](https://github.com/ugurkupeli) --- ### Overview (`21_Calendar/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`22_Change/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`22_Change/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`22_Change/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`22_Change/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`22_Change/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`22_Change/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`22_Change/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`22_Change/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`22_Change/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`22_Change/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`23_Checkers/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`23_Checkers/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`23_Checkers/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`23_Checkers/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`23_Checkers/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`23_Checkers/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) Note: This version has lines and columns numbers to help you with choosing the cell to move from and to, so you don't have to continually count. It also puts a "." only for blank cells you can move to, which I think makes for a more pleasing look and makes it easier to play. If you want the original behavior, start the program with an arg of "-o" for the original behavior. --- ### Overview (`23_Checkers/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`23_Checkers/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) This version preserves the underlying algorithms and functionality of the original while using more modern programming constructs (functions, classes, symbols) and providing much more detailed comments. It also fixes some (but not all) of the bugs. --- ### Overview (`23_Checkers/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`24_Chemist/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`24_Chemist/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`24_Chemist/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`24_Chemist/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`24_Chemist/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`24_Chemist/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`24_Chemist/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`24_Chemist/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`24_Chemist/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`24_Chemist/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`25_Chief/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`25_Chief/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`25_Chief/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`25_Chief/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`25_Chief/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) by Alex Conconi --- ### Lua porting notes - I did not like the old Western movie language style in the game introduction and decided to tone it down, even if this deviates from the original BASIC version. - The `craps_game` function contains the main game logic: it - prints the game credits and presents the intro question; - asks for the end result and computes the original numer; - calls `explain_solution` to print the various steps of the computation; - presents the outro question and prints a `bolt` if necessary. - Added basic input validation to accept only valid integers for numeric input. - Minor formatting edits (lowercase, punctuation). - Any answer to a "yes or no" question is regarded as "yes" if the input line starts with 'y' or 'Y', else no. --- ### Overview (`25_Chief/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`25_Chief/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`25_Chief/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`25_Chief/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by [Jadi](https://github.com/jadijadi) --- ### Overview (`25_Chief/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`26_Chomp/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`26_Chomp/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`26_Chomp/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`26_Chomp/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`26_Chomp/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`26_Chomp/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`26_Chomp/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`26_Chomp/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`26_Chomp/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`27_Civil_War/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`27_Civil_War/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`27_Civil_War/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`27_Civil_War/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`27_Civil_War/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`27_Civil_War/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`27_Civil_War/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`27_Civil_War/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`27_Civil_War/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`28_Combat/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) The original BASIC code has a surprising number of bugs for such a small program. For the sake of preserving the original behaviour, I've left them in place and commented the ones I noticed. --- ### Overview (`28_Combat/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`28_Combat/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`28_Combat/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`28_Combat/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`28_Combat/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`28_Combat/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`28_Combat/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`28_Combat/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`29_Craps/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`29_Craps/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`29_Craps/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`29_Craps/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`29_Craps/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) by Alex Conconi --- ### Lua porting notes - The `craps_main` function contains the main game loop, which iteratively plays craps rounds by calling `play_round` and tracks winnings and losings. - Replaced the original routine that tries to scramble the random number generator with a proper seed initializer in Lua: `math.randomseed(os.time())` (as advised in the general porting notes). - Added basic input validation to accept only positive integers for the wager and the answer to the "If you want to play again print 5" question. - "If you want to play again print 5 if not print 2" reads a bit odd but we decided to leave it as is and stay true to the BASIC original version. --- ### Overview (`29_Craps/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`29_Craps/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`29_Craps/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`29_Craps/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`30_Cube/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) #### Execution As noted in the main Readme file, the randomization code in the BASIC program has a switch (the variable `X`) that allows the game to be run in a deterministic (non-random) mode. Running the C# port without command-line parameters will play the game with random mine locations. Running the port with a `--non-random` command-line switch will run the game with non-random mine locations. --- ### Overview (`30_Cube/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`30_Cube/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`30_Cube/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`30_Cube/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`30_Cube/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`30_Cube/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`30_Cube/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`30_Cube/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`31_Depth_Charge/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`31_Depth_Charge/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`31_Depth_Charge/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`31_Depth_Charge/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`31_Depth_Charge/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`31_Depth_Charge/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) ## Conversion Not a difficult conversion - but a chance to throw in a few ways Perl makes life easy. * To get the sub permission which is a random location in the g x g x g grid we can use: * assigning multiple variables in list form ($a,$b,$c) = (?,?,?) * where the list on the right hand side is generated with a map function * We use ternarys to generate the message if you miss the sub. * We use join to stitch the pieces of the string together. * If we have a ternary where we don't want to return anything we return an empty list rather than an empty string - if you return the latter you still get the padding spaces. --- ### Overview (`31_Depth_Charge/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`31_Depth_Charge/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`31_Depth_Charge/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`32_Diamond/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`32_Diamond/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`32_Diamond/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`32_Diamond/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/), structure inspired from [the Java port](https://github.com/coding-horror/basic-computer-games/blob/main/32_Diamond/java/Diamond.java). ### How to Run 1. Install [kotlin command line](https://kotlinlang.org/docs/command-line.html) compiler from JetBrains. 2. Compile with `kotlinc diamond.kt -include-runtime -d diamond.jar` 3. Run with `java -jar diamond.jar` ### Changes from Original This version validates that user input is correct. --- ### Overview (`32_Diamond/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`32_Diamond/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`32_Diamond/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`32_Diamond/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`32_Diamond/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`32_Diamond/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`33_Dice/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) by James Curran (http://www.noveltheory.com) --- ### Overview (`33_Dice/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`33_Dice/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`33_Dice/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`33_Dice/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) by Alex Conconi --- ### Porting notes for Lua - This is a straightfoward port with only minor modifications for input validation and text formatting. - The "Try again?" question accepts 'y', 'yes', 'n', 'no' (case insensitive), whereas the original BASIC version defaults to no unless 'YES' is typed. - The "How many rolls?" question presents a more user friendly message in case of invalid input. --- ### Overview (`33_Dice/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`33_Dice/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`33_Dice/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`33_Dice/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`33_Dice/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`34_Digits/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`34_Digits/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`34_Digits/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`34_Digits/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`34_Digits/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`34_Digits/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`34_Digits/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`34_Digits/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`34_Digits/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`35_Even_Wins/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`35_Even_Wins/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`35_Even_Wins/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`35_Even_Wins/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`35_Even_Wins/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`35_Even_Wins/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`35_Even_Wins/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`35_Even_Wins/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`35_Even_Wins/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`36_Flip_Flop/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`36_Flip_Flop/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`36_Flip_Flop/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`36_Flip_Flop/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`36_Flip_Flop/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`36_Flip_Flop/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`36_Flip_Flop/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`36_Flip_Flop/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`36_Flip_Flop/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`37_Football/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`37_Football/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`37_Football/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`37_Football/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`37_Football/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`37_Football/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`37_Football/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) ## Porting notes Variables: * E: score_limit * H(2): Scores * T(2): Team toggle * T: team who currently possesses the ball * L: Offset * P: Who has the ball * K: yards * R: Runback current team in yards * P$(20): Actions (see data.json) Functions: * `P$(I)`: Access index `I` of the `P` array * ABS: abs (absolute value) * RND(1): random() * GOSUB: Execute a function - will jump back to this * GOTO: Just jump Patterns: * `T=T(T)`: Toggle the team who currently has the ball --- ### Overview (`37_Football/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`37_Football/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`38_Fur_Trader/c/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [ANSI-C](https://en.wikipedia.org/wiki/ANSI_C) ##### Translator Notes: I tried to preserve as much of the original layout and flow of the code as possible. However I did use enumerated types for the Fort numbers and Fur types. I think this was certainly a change for the better, and makes the code much easier to read. I also tried to minimise the use of pointers, and stuck with old-school C formatting, because you never know how old the compiler is. Interestingly the code seems to have a bug around the prices of Fox Furs. The commodity-rate for these is stored in the variable `D1`, however some paths through the code do not set this price. So there was a chance of using this uninitialised, or whatever the previous loop set. I don't think this was the original authors intent. So I preserved the original flow of the code (using the previous `D1` value), but also catching the uninitialised path, and assigning a "best guess" value. krt@krt.com.au 2020-10-10 --- ### Overview (`38_Fur_Trader/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`38_Fur_Trader/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`38_Fur_Trader/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`38_Fur_Trader/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`38_Fur_Trader/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`38_Fur_Trader/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) You can answer yes/no questions in lower case if desired. --- ### Overview (`38_Fur_Trader/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) ##### Translator Notes: I tried to preserve as much of the original layout and flow of the code as possible. However I did use quasi enumerated types for the Fort numbers and Fur types. I think this was certainly a change for the better, and makes the code much easier to read. I program in many different languages on a daily basis. Most languages require brackets around expressions, so I just cannot bring myself to write an expression without brackets. IMHO it makes the code easier to study, but it does contravene the Python PEP-8 Style guide. Interestingly the code seems to have a bug around the prices of Fox Furs. The commodity-rate for these is stored in the variable `D1`, however some paths through the code do not set this price. So there was a chance of using this uninitialised, or whatever the previous loop set. I don't think this was the original authors intent. So I preserved the original flow of the code (using the previous `D1` value), but also catching the uninitialised path, and assigning a "best guess" value. krt@krt.com.au 2020-10-10 --- ### Overview (`38_Fur_Trader/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`38_Fur_Trader/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`39_Golf/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) There are 2 compiled executables in the compiled/ directory (windows and linux) that you can play right away! Program.cs contains the C# source code. It has been written for .NET Core 3.1 The source code is well documented. --- ### Overview (`39_Golf/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`39_Golf/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`39_Golf/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`39_Golf/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`39_Golf/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`39_Golf/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`39_Golf/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`39_Golf/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`40_Gomoko/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`40_Gomoko/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`40_Gomoko/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`40_Gomoko/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`40_Gomoko/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`40_Gomoko/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`40_Gomoko/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`40_Gomoko/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`40_Gomoko/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`41_Guess/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`41_Guess/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`41_Guess/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`41_Guess/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`41_Guess/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`41_Guess/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`41_Guess/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`41_Guess/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`41_Guess/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`41_Guess/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`42_Gunner/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`42_Gunner/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`42_Gunner/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`42_Gunner/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`42_Gunner/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`42_Gunner/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`42_Gunner/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`42_Gunner/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`42_Gunner/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`43_Hammurabi/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`43_Hammurabi/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`43_Hammurabi/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`43_Hammurabi/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`43_Hammurabi/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`43_Hammurabi/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`43_Hammurabi/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`43_Hammurabi/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`43_Hammurabi/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`43_Hammurabi/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`44_Hangman/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`44_Hangman/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`44_Hangman/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`44_Hangman/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`44_Hangman/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`44_Hangman/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`44_Hangman/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`44_Hangman/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`44_Hangman/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`45_Hello/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`45_Hello/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`45_Hello/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`45_Hello/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`45_Hello/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`45_Hello/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`45_Hello/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`45_Hello/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`45_Hello/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`46_Hexapawn/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`46_Hexapawn/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`46_Hexapawn/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`46_Hexapawn/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`46_Hexapawn/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`46_Hexapawn/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`46_Hexapawn/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`46_Hexapawn/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`46_Hexapawn/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`47_Hi-Lo/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`47_Hi-Lo/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`47_Hi-Lo/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`47_Hi-Lo/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`47_Hi-Lo/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`47_Hi-Lo/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`47_Hi-Lo/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`47_Hi-Lo/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) by [R.T. Lechow](https://github.com/rtlechow) --- ### Overview (`47_Hi-Lo/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`47_Hi-Lo/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`48_High_IQ/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`48_High_IQ/d/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html) Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo). ## Running the code Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler: ```shell dmd -dip1000 -run highiq.d ``` [Other compilers](https://dlang.org/download.html) also exist. ## Discussion The original BASIC game code made use of calculus and clever choises of field IDs to determine the validity of moves. This is the original layout of IDs over the board: ``` 13 14 15 22 23 24 29 30 31 32 33 34 35 38 39 40 41 42 43 44 47 48 49 50 51 52 53 58 59 60 67 68 69 ``` This seems not very logical, because, wouldn't it make much more sense to let columns increase with 1 and rows increase with 10, so you'd get a consistent coordinate system? It seems that the original author's first step in validating moves was to check that moves jumped from one field over another one onto the next. He did this by making sure that adjacent IDs alter between even and odd horizontally *and* vertically. So a valid move was always from an even ID to an even ID *or* from an odd ID to an odd ID. So one of the checks that the BASIC code made was that the sum of both IDs was even. This is of course not a sufficient test, because moves that jump over three fields are illegal. Therefore the IDs seem to have been carefully laid oud so that the IDs increase with 1 horizontally, and 9 vertically, everywhere. So the only valid difference between IDs for a horizontal move was always 2, and the only valid difference for a vertical move was always 18. Fact of the matter is, however, that checking for difference is sufficient and the even sum rule is superfluous, so there is no need for the peculiar distribution of field IDs. Therefore I have chosen the following more logical distribution: ``` 13 14 15 23 24 25 31 32 33 34 35 36 37 41 42 43 44 45 46 47 51 52 53 54 55 56 57 63 64 65 73 74 75 ``` As a consequence, the implementation of the game code has become much simpler; Not alone due to one less check, but due to the fact that conversions between IDs and board coordinates have become unnecessary and thus we can work with a single representation of the board state. This version makes a prettier print of the board than the BASIC original, with coordinates for every move, and explains illegal moves. ## Demo ``` /* Detailed source-code truncated for AI context efficiency. */ ``` --- ### Overview (`48_High_IQ/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`48_High_IQ/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`48_High_IQ/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`48_High_IQ/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`48_High_IQ/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`48_High_IQ/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) [Implementation](./High_IQ.py) by [Thomas Kwashnak](https://github.com/LittleTealeaf) --- ### Overview (`48_High_IQ/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`48_High_IQ/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`49_Hockey/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`49_Hockey/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`49_Hockey/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`49_Hockey/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`49_Hockey/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`49_Hockey/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`49_Hockey/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) ## Porting Notes Variables: * C: Do you want instructions? * A$(7): Team name + player names (6 players) * B$(7): Team name + player names (6 players) * T6: Minutes per game * R: REFEREE Functions: * REM: A line comment * `INT(2*RND(X))+1`: X is constantly 1. That means that this expression is simpler expressed as `randint(1,2)` --- Looking at the JS implementation: * as[7] / bs[7]: The team name * ha[8] : Score of team B * ha[9] : Score of team A --- ### Overview (`49_Hockey/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`49_Hockey/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`50_Horserace/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`50_Horserace/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`50_Horserace/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`50_Horserace/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`50_Horserace/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`50_Horserace/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`50_Horserace/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`50_Horserace/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`50_Horserace/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`51_Hurkle/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) This is demonstrating seperating the user interface from the application logic through the use of the View/ViewModel/Controller pattern. It also makes an effort to be relatively immutable. --- ### Overview (`51_Hurkle/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`51_Hurkle/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`51_Hurkle/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`51_Hurkle/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`51_Hurkle/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`51_Hurkle/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`51_Hurkle/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`51_Hurkle/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`52_Kinema/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`52_Kinema/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`52_Kinema/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`52_Kinema/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`52_Kinema/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`52_Kinema/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`52_Kinema/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`52_Kinema/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`52_Kinema/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`53_King/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`53_King/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`53_King/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`53_King/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`53_King/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`53_King/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`53_King/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) ## Porting notes Variables: * A: Available rallods (money) * B: Current countrymen * C: foreign_workers * C1: foreign_workers_influx * D: Available land (farmland=D-1000) * F1: polution_deaths (last round) * B5: died_contrymen (starvation + pollution) * H: sm_sell_to_industry * I: distributed_rallods * J: planted_sq in a round * K: pollution_control_spendings in a round * X5: years in office * N5: YEARS_IN_TERM - how many years one term in office has * P1: population_change (positive means people come, negative means people leave) * W: land_buy_price * V9: planting_cost * U2: crop_loss * V1-V2: Earnings from tourist trade * V3: tourism_earnings * T1: crop_loss_last_year * W: land_buy_price * X: only show an error message once Functions: * `RND(1)`: `random.random()` * `INT(...)`: `int(...)` * `ABS(...)`: `abs(...)` Bugs: See [53 King README](../README.md) Implicit knowledge: * `COST_OF_LIVING`: One countryman needs 100 for food. Otherwise they will die of starvation * `COST_OF_FUNERAL`: A funeral costs 9 --- ### Overview (`53_King/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`53_King/rust/README.md`) King ==== Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [rust](https://www.rust-lang.org/). Porting Notes ------------- ### Floats The original code implicitly uses floating point numbers in many places which are explicitly cast to integers. In this port, I avoided using floats and tried to replicate the behaviour using just integers. It is possible that I missed some places where rounding a value would have made a difference. If you find such a bug, please notify me or make implement a fix yourself. ### Signed Numbers I used unsigned integers for most of the program because it was easier than to check for negative values all the time. Unfortunately, that made the code a bit whacky in one or two places. Since I only allow input of positive numbers, it is not possible to exit the game when entering the stats to resume a game, which would be possible by entering negative numbers in the original game. ### Bugs I tried to fix all bugs listed in the [main README for King](../README.md). I have tested this implementation a bit but not extensively, so there may be some portation bugs. If you find them, you are free to fix them. Future Development ------------------ I plan to add some tests and tidy up the code a bit, but this version should be feature-complete. --- ### Overview (`53_King/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`54_Letter/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`54_Letter/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`54_Letter/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`54_Letter/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`54_Letter/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`54_Letter/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`54_Letter/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`54_Letter/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`54_Letter/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`54_Letter/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`55_Life/csharp/README.md`) # Life An implementation of John Conway's popular cellular automaton, also know as **Conway's Game of Life**. The original source was downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html). Ported by Dyego Alekssander Maas. ## How to run This program requires you to install [.NET 6 SDK](https://dotnet.microsoft.com/en-us/download/dotnet/6.0). After installed, you just need to run `dotnet run` from this directory in the terminal. ## Know more about Conway's Game of Life You can find more about Conway's Game of Life on this page of the [Cornell Math Explorers' Club](http://pi.math.cornell.edu/~lipa/mec/lesson6.html), alongside many examples of patterns you can try. ### Optional parameters Optionally, you can run this program with the `--wait 1000` argument, the number being the time in milliseconds that the application will pause between each iteration. This is enables you to watch the simulation unfolding. By default, there is no pause between iterations. The complete command would be `dotnet run --wait 1000`. ## Entering patterns Once running the game, you are expected to enter a pattern. This pattern consists of multiple lines of text with either **spaces** or **some character**, usually an asterisk (`*`). Spaces represent empty cells. Asterisks represent alive cells. After entering the pattern, you need to enter the word "DONE". It is not case sensitive. An example of pattern would be: ``` * *** DONE ``` ### Some patterns you could try ``` * *** ``` ``` * *** ``` ``` ** ** ``` ``` * * * ``` This one is known as **glider**: ``` *** * * ``` ## Instructions to the port Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`55_Life/java/README.md`) # Game of Life - Java version Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) ## Requirements * Requires Java 17 (or later) ## Notes The Java version of Game of Life tries to mimics the behaviour of the BASIC version. However, the Java code does not have much in common with the original. **Differences in behaviour:** * Input supports the ```.``` character, but it's optional. * Evaluation of ```DONE``` input string is case insensitive. * Run with the ```-s``` command line argument to halt the program after each generation, and continue when ```ENTER``` is pressed. --- ### Overview (`55_Life/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`55_Life/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`55_Life/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`55_Life/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`55_Life/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`55_Life/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`55_Life/rust/README.md`) # Conway's Life Original from David Ahl's _Basic Computer Games_, downloaded from http://www.vintage-basic.net/games.html. Ported to Rust by Jon Fetter-Degges Developed and tested on Rust 1.64.0 ## How to Run Install Rust using the instructions at [rust-lang.org](https://www.rust-lang.org/tools/install). At a command or shell prompt in the `rust` subdirectory, enter `cargo run`. ## Differences from Original Behavior * The simulation stops if all cells die. * `.` at the beginning of an input line is supported but optional. * Input of more than 66 columns is rejected. Input will automatically terminate after 20 rows. Beyond these bounds, the original implementation would have marked the board as invalid, and beyond 68 cols/24 rows it would have had an out of bounds array access. * The check for the string "DONE" at the end of input is case-independent. * The program pauses for half a second between each generation. --- ### Overview (`55_Life/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`56_Life_for_Two/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`56_Life_for_Two/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`56_Life_for_Two/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`56_Life_for_Two/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`56_Life_for_Two/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`56_Life_for_Two/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) Note: The original program has a bug (see the README in the above dir). This Perl version fixes it. Note: For input, the X value is to the right while the Y value is down. Therefore, the top right cell is "5,1", not "1,5". The original program was made to be played on a Teletype, i.e. a printer on paper. That allowed the program to "black out" the input line to hide a user's input from his/her opponent, assuming the opponent was at least looking away. To do the equivalent on a terminal would require a Perl module that isn't installed by default (i.e. it is not part of CORE and would also require a C compiler to install), nor do I want to issue a shell command to "stty" to hide the input because that would restrict the game to Linux/Unix. This means it would have to be played on the honor system. However, if you want to try it, install the module "Term::ReadKey" ("sudo cpan -i Term::ReadKey" if on Linux/Unix and you have root access). If the code finds that module, it will automatically use it and hide the input ... and restore echoing input again when the games ends. If the module is not found, input will be visible. --- ### Overview (`56_Life_for_Two/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`56_Life_for_Two/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`56_Life_for_Two/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`57_Literature_Quiz/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`57_Literature_Quiz/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`57_Literature_Quiz/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`57_Literature_Quiz/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`57_Literature_Quiz/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`57_Literature_Quiz/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`57_Literature_Quiz/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`57_Literature_Quiz/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`57_Literature_Quiz/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`57_Literature_Quiz/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`58_Love/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`58_Love/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`58_Love/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`58_Love/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`58_Love/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`58_Love/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`58_Love/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`58_Love/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`58_Love/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Jadi. --- ### Overview (`58_Love/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`59_Lunar_LEM_Rocket/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`59_Lunar_LEM_Rocket/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`59_Lunar_LEM_Rocket/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`59_Lunar_LEM_Rocket/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`59_Lunar_LEM_Rocket/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`59_Lunar_LEM_Rocket/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`59_Lunar_LEM_Rocket/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`59_Lunar_LEM_Rocket/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`59_Lunar_LEM_Rocket/rust/README.md`) README.md Original source downloaded from Vintage Basic This folder for chapter #59 contains three different games. Three folders here contain the three games: - Rocket - LEM - lunar Conversion to [Rust](https://www.rust-lang.org) --- ### Overview (`59_Lunar_LEM_Rocket/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`60_Mastermind/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`60_Mastermind/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`60_Mastermind/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`60_Mastermind/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`60_Mastermind/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`60_Mastermind/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) This is pretty much a re-implementation of the BASIC, taking advantage of Perl's array functionality and working directly with the alphabetic color codes. --- ### Overview (`60_Mastermind/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`60_Mastermind/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`60_Mastermind/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`61_Math_Dice/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) Conversion Notes - There are minor spacing issues which have been preserved in this port. - This implementation uses switch expressions to concisely place the dice pips in the right place. - Random() is only pseudo-random but perfectly adequate for the purposes of simulating dice rolls. - Console width is assumed to be 120 chars for the purposes of centrally aligned the intro text. --- ### Overview (`61_Math_Dice/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`61_Math_Dice/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`61_Math_Dice/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`61_Math_Dice/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`61_Math_Dice/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`61_Math_Dice/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`61_Math_Dice/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`61_Math_Dice/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) If you wish to give the user more than 2 attempts to get the number, change value assigned to the num_tries variable at the start of the main function --- ### Overview (`61_Math_Dice/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`62_Mugwump/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`62_Mugwump/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`62_Mugwump/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`62_Mugwump/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`62_Mugwump/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`62_Mugwump/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`62_Mugwump/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`62_Mugwump/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`62_Mugwump/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`63_Name/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`63_Name/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`63_Name/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`63_Name/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`63_Name/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`63_Name/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`63_Name/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`63_Name/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`63_Name/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`64_Nicomachus/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`64_Nicomachus/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`64_Nicomachus/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`64_Nicomachus/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`64_Nicomachus/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`64_Nicomachus/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`64_Nicomachus/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`64_Nicomachus/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`64_Nicomachus/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`65_Nim/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`65_Nim/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`65_Nim/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`65_Nim/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`65_Nim/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`65_Nim/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`65_Nim/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`65_Nim/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`65_Nim/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`66_Number/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`66_Number/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`66_Number/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`66_Number/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`66_Number/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`66_Number/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`66_Number/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`66_Number/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`66_Number/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`66_Number/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`67_One_Check/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`67_One_Check/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`67_One_Check/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`67_One_Check/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`67_One_Check/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`67_One_Check/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`67_One_Check/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`67_One_Check/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`67_One_Check/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`68_Orbit/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`68_Orbit/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`68_Orbit/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`68_Orbit/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`68_Orbit/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`68_Orbit/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) This Perl script is a port of orbit, which is the 68th entry in Basic Computer Games. In this game you are a planetary defense gunner trying to shoot down a cloaked Romulan ship before it can escape. This is pretty much a straight port of the BASIC into idiomatic Perl. --- ### Overview (`68_Orbit/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`68_Orbit/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`68_Orbit/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`68_Orbit/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`69_Pizza/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`69_Pizza/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`69_Pizza/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`69_Pizza/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`69_Pizza/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`69_Pizza/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`69_Pizza/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`69_Pizza/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`69_Pizza/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/). --- ### Overview (`69_Pizza/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`70_Poetry/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`70_Poetry/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`70_Poetry/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`70_Poetry/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`70_Poetry/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`70_Poetry/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`70_Poetry/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`70_Poetry/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`70_Poetry/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`71_Poker/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`71_Poker/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`71_Poker/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`71_Poker/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`71_Poker/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`71_Poker/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`71_Poker/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`71_Poker/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`71_Poker/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`72_Queen/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`72_Queen/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`72_Queen/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`72_Queen/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`72_Queen/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`72_Queen/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`72_Queen/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) by Christopher Phan. Supports Python version 3.8 or later. --- ### Overview (`72_Queen/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`72_Queen/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`73_Reverse/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`73_Reverse/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`73_Reverse/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`73_Reverse/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`73_Reverse/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`73_Reverse/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`73_Reverse/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`73_Reverse/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`73_Reverse/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`74_Rock_Scissors_Paper/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`74_Rock_Scissors_Paper/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`74_Rock_Scissors_Paper/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`74_Rock_Scissors_Paper/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`74_Rock_Scissors_Paper/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`74_Rock_Scissors_Paper/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`74_Rock_Scissors_Paper/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`74_Rock_Scissors_Paper/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`74_Rock_Scissors_Paper/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org) --- ### Overview (`74_Rock_Scissors_Paper/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`75_Roulette/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`75_Roulette/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) Two versions of Roulette has been contributed. They are indicated within given sub-folders - [oop](./oop) - Conversion by Andrew McGuinness (andrew@arobeia.co.uk) - [iterative](./iterative) - Conversion by Thomas Kwashnak ([Github](https://github.com/LittleTealeaf)). - Implements features from JDK 17. - Does make use of some object oriented programming, but acts as a more iterative solution. --- ### Overview (`75_Roulette/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`75_Roulette/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`75_Roulette/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`75_Roulette/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) This conversion consists of three files in `75_Roulette/perl/`: - `roulette.pl` is the port of the BASIC to Perl; - `roulette-test.t` is a Perl test for correctness of display and payout; - `make-roulette-test.pl` generates roulette-test.t from roulette.bas. The ported version of the game numbers the slots from 0 rather than 1, and uses a dispatch table to figure out the payout. The Perl test loads `roulette.pl` and verifies the Perl slot display and payout logic against the BASIC for all combinations of slots and bets. If any tests fail that fact will be noted at the end of the output. The test code is generated by reading the BASIC, retaining only the slot display and payout logic (based on line numbers), and wrapping this in code that generates all combinations of bet and spin result. The result is run, and the result is captured and parsed to produce `roulette-test.t`. `make-roulette-test.pl` has some command-line options that may be of interest. `--help` will display the documentation. --- ### Overview (`75_Roulette/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`75_Roulette/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`75_Roulette/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`76_Russian_Roulette/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`76_Russian_Roulette/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`76_Russian_Roulette/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`76_Russian_Roulette/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`76_Russian_Roulette/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`76_Russian_Roulette/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`76_Russian_Roulette/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`76_Russian_Roulette/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`76_Russian_Roulette/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`77_Salvo/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`77_Salvo/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`77_Salvo/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`77_Salvo/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`77_Salvo/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`77_Salvo/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`77_Salvo/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`77_Salvo/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`77_Salvo/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`78_Sine_Wave/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`78_Sine_Wave/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`78_Sine_Wave/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`78_Sine_Wave/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`78_Sine_Wave/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`78_Sine_Wave/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`78_Sine_Wave/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`78_Sine_Wave/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`78_Sine_Wave/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`78_Sine_Wave/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`79_Slalom/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`79_Slalom/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`79_Slalom/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`79_Slalom/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`79_Slalom/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`79_Slalom/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`79_Slalom/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`79_Slalom/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`79_Slalom/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`80_Slots/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) This C# implementation of slots was done using a [C# script](https://github.com/filipw/dotnet-script). # Required [.NET Core SDK (i.e., .NET 6.0)](https://dotnet.microsoft.com/en-us/download) Install dotnet-script. On the command line run: ``` dotnet tool install -g dotnet-script ``` # Run ``` dotnet script .\slots.csx ``` --- ### Overview (`80_Slots/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`80_Slots/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`80_Slots/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`80_Slots/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`80_Slots/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) This Perl script is a port of slots, which is the 80th entry in Basic Computer Games. I know nothing about slot machines, and my research into them says to me that the payout tables can be fairly arbitrary. But I have taken the liberty of deeming the BASIC program's refusal to pay on LEMON CHERRY LEMON a bug, and made that case a double. My justification for this is that at the point where the BASIC has detected the double in the first and third reels it has already detected that there is no double in the first and second reels. After the check for a bar (and therefore a double bar) fails it goes back and checks for a double on the second and third reels. But we know this check will fail, since the check for a double on the first and second reels failed. So if a loss was intended at this point, why not just call it a loss? To restore the original behavior, comment out the entire line commented '# Bug fix?' (about line 75) and uncomment the line with the trailing comment '# Bug?' (about line 83). --- ### Overview (`80_Slots/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`80_Slots/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`80_Slots/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`81_Splat/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`81_Splat/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Java](https://openjdk.java.net/) --- ### Overview (`81_Splat/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`81_Splat/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`81_Splat/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`81_Splat/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`81_Splat/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`81_Splat/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`81_Splat/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`82_Stars/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`82_Stars/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`82_Stars/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`82_Stars/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`82_Stars/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`82_Stars/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`82_Stars/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`82_Stars/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`82_Stars/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) --- ### Overview (`82_Stars/rust_JWB/README.md`) <<<<<<< HEAD #STARS From: BASIC Computer Games (1978), edited by David H. Ahl In this game, the computer selects a random number from 1 to 100 (or any value you set [for MAX_NUM]). You try to guess the number and the computer gives you clues to tell you how close you're getting. One star (*) means you're far away from the number; seven stars (*******) means you're really close. You get 7 guesses. On the surface this game is very similar to GUESS; however, the guessing strategy is quite different. See if you can come up with one or more approaches to finding the mystery number. Bob Albrecht of People's Computer Company created this game. ## NOTES Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by JW Bruce thanks to Jeff Jetton for his Python port which provide inspiration ======= Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) >>>>>>> 3e27c70ca800f5efbe6bc1a7d180211decf55b7d --- ### Overview (`82_Stars/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`83_Stock_Market/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`83_Stock_Market/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`83_Stock_Market/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`83_Stock_Market/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`83_Stock_Market/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`83_Stock_Market/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`83_Stock_Market/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`83_Stock_Market/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`83_Stock_Market/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`84_Super_Star_Trek/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`84_Super_Star_Trek/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) by [Taciano Dreckmann Perez](https://github.com/taciano-perez). Overview of Java classes: - SuperStarTrekInstructions: displays game instructions - SuperStarTrekGame: main game class - GalaxyMap: map of the galaxy divided in quadrants and sectors, containing stars, bases, klingons, and the Enterprise - Enterprise: the starship Enterprise - GameCallback: interface allowing other classes to interact with the game class without circular dependencies - Util: utility methods [This video](https://www.youtube.com/watch?v=cU3NKOnRNCI) describes the approach and the different steps followed to translate the game. --- ### Overview (`84_Super_Star_Trek/javascript/README.md`) Original source downloaded [from Vintage Basic][def] Conversion to [****J****avaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) [def]: http://www.vintage-basic.net/games.html --- ### Overview (`84_Super_Star_Trek/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`84_Super_Star_Trek/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`84_Super_Star_Trek/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`84_Super_Star_Trek/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`84_Super_Star_Trek/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`84_Super_Star_Trek/rust/readme.md`) # Super Star Trek - Rust version Explanation of modules: - [main.rs](./src/main.rs) - creates the galaxy (generation functions are in model.rs as impl methods) then loops listening for commands. after each command checks for victory or defeat condtions. - [model.rs](./src/model.rs) - all the structs and enums that represent the galaxy. key methods in here (as impl methods) are generation functions on galaxy and quadrant, and various comparison methods on the 'Pos' tuple type. - [commands.rs](./src/commands.rs) - most of the code that implements instructions given by the player (some code logic is in the model impls, and some in view.rs if its view only). - [view.rs](./src/view.rs) - all text printed to the output, mostly called by command.rs (like view::bad_nav for example). also contains the prompts printed to the user (e.g. view::prompts::COMMAND). - [input.rs](./src/input.rs) - utility methods for getting input from the user, including logic for parsing numbers, repeating prompts until a correct value is provided etc. Basically the user is asked for the next command, this runs a function that usually checks if the command system is working, and if so will gather additional input (see next note for a slight change here), then either the model is read and info printed, or its mutated in some way (e.g. firing a torpedo, which reduces the torpedo count on the enterprise and can destroy klingons and star bases; finally the klingons fire back and can destroy the enterprise). Finally the win/lose conditions are checked before the loop repeats. ## Changes from the original I have tried to keep it as close as possible. Notable changes are: - commands can be given with parameters in line. e.g. while 'nav' will ask for course and then warp speed in the original, here you can *optionally* also do this as one line, e.g. `nav 1 0.1` to move one sector east. I'm sorry - it was driving me insane in its original form (which is still sorted, as is partial application e.g. nav 1 to preset direction and then provide speed). - text is mostly not uppercase, as text was in the basic version. this would be easy to change however as all text is in view.rs, but I chose not to. - the navigation system (plotting direction, paths and collision detection) is as close as I could make it to the basic version (by using other language conversions as specification sources) but I suspect is not perfect. seems to work well enough however. --- ### Overview (`84_Super_Star_Trek/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`85_Synonym/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`85_Synonym/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`85_Synonym/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`85_Synonym/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`85_Synonym/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`85_Synonym/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) I used List::Util to do all the heavy work to show that perl can handle all the various array functions. It would be interesting to see a version that handled all of this manually as there ended up being very little code left in this program. --- ### Overview (`85_Synonym/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`85_Synonym/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`85_Synonym/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by [Jadi](https://github.com/jadijadi) --- ### Overview (`85_Synonym/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`86_Target/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`86_Target/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`86_Target/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`86_Target/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`86_Target/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`86_Target/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) Modified so that if the user enters "quit" or "stop" for the input, the program will exit. This way the user doesn't have to enter Contorl-C to quit. Target values can be space and/or comma separated, so "1 2 3" is valid, as is "1,2,3" or even "1, 2, 3". I believe the original Basic program wanted "1,2,3" or else each on a separate line. --- ### Overview (`86_Target/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`86_Target/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`86_Target/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`87_3-D_Plot/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`87_3-D_Plot/d/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html) Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo). ## Running the code Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler: ```shell dmd -dip1000 -run threedeeplot.d ``` [Other compilers](https://dlang.org/download.html) also exist. ## On rounding floating point values to integer values The D equivalent of Basic `INT` is [`floor`](https://dlang.org/phobos/std_math_rounding.html#.floor), which rounds towards negative infinity. If you change occurrences of `floor` to [`lrint`](https://dlang.org/phobos/std_math_rounding.html#.lrint), you'll see that the plots show a bit more detail, as is done in the bonus below. ## Bonus: Self-writing programs With a small modification to the source, the program can be extended to **plot a random function**, and **print its formula**. ```shell rdmd -dip1000 threedeeplot_random.d ``` (`rdmd` caches the executable, which results in speedy execution when the source does not change.) ### Example output ``` /* Detailed source-code truncated for AI context efficiency. */ ``` ### Breakdown of differences Have a look at the relevant differences between `threedeeplot.d` and `threedeeplot_random.d`. This is the original function with the single expression that is evaluated for the plot: ```d static float fna(float z) { return 30.0 * exp(-z * z / 100.0); } ``` Here `static` means that the nested function does not need acces to its enclosing scope. Now, by inserting the following: ```d enum functions = ["30.0 * exp(-z * z / 100.0)", "sqrt(900.01 - z * z) * .9 - 2", "30 * (cos(z / 16.0) + .5)", "30 - 30 * sin(z / 18.0)", "30 * exp(-cos(z / 16.0)) - 30", "30 * sin(z / 10.0)"]; size_t index = uniform(0, functions.length); writeln(center("f(z) = " ~ functions[index], width), "\n"); ``` and changing the implementation of `fna` to ```d float fna(float z) { final switch (index) { static foreach (i, f; functions) case i: mixin("return " ~ f ~ ";"); } } ``` we unlock some very special abilities of D. Let's break it down: ```d enum functions = ["30.0 * exp(-z * z / 100.0)", /*...*/]; ``` This defines an array of strings, each containing a mathematical expression. Due to the `enum` keyword, this is an array that really only exists at compile-time. ```d size_t index = uniform(0, functions.length); ``` This defines a random index into the array. `functions.length` is evaluated at compile-time, due to D's compile-time function evaluation (CTFE). ```d writeln(center("f(z) = " ~ functions[index], width), "\n"); ``` Unmistakenly, this prints the formula centered on a line. What happens behind the scenes is that `functions` (which only existed at compile-time before now) is pasted in, so that an instance of that array actually exists at run-time at this spot, and is instantly indexed. ```d float fna(float z) { final switch (index) { // ... } } ``` `static` has been dropped from the nested function because we want to evaluate `index` inside it. The function contains an ordinary `switch`, with `final` providing some extra robustness. It disallows a `default` case and produces an error when the switch doesn't handle all cases. The `switch` body is where the magic happens and consists of these three lines: ```d static foreach (i, f; functions) case i: mixin("return " ~ f ~ ";"); ``` The `static foreach` iterates over `functions` at compile-time, producing one `case` for every element in `functions`. `mixin` takes a string, which is constructed at compile-time, and pastes it right into the source. In effect, the implementation of `float fna(float z)` unrolls itself into ```d float fna(float z) { final switch (index) { case 0: return 30.0 * exp(-z * z / 100.0); case 1: return sqrt(900.01 - z * z) * .9 - 2; case 2: return 30 * (cos(z / 16.0) + .5); case 3: return 30 - 30 * sin(z / 18.0); case 4: return 30 * exp(-cos(z / 16.0)) - 30; case 5: return 30 * sin(z / 10.0)"; } } ``` So if you feel like adding another function, all you need to do is append it to the `functions` array, and the rest of the program *rewrites itself...* --- ### Overview (`87_3-D_Plot/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`87_3-D_Plot/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`87_3-D_Plot/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`87_3-D_Plot/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`87_3-D_Plot/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`87_3-D_Plot/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`87_3-D_Plot/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`87_3-D_Plot/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`88_3-D_Tic-Tac-Toe/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`88_3-D_Tic-Tac-Toe/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`88_3-D_Tic-Tac-Toe/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`88_3-D_Tic-Tac-Toe/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`88_3-D_Tic-Tac-Toe/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`88_3-D_Tic-Tac-Toe/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`88_3-D_Tic-Tac-Toe/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`88_3-D_Tic-Tac-Toe/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`88_3-D_Tic-Tac-Toe/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`89_Tic-Tac-Toe/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`89_Tic-Tac-Toe/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`89_Tic-Tac-Toe/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`89_Tic-Tac-Toe/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`89_Tic-Tac-Toe/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`89_Tic-Tac-Toe/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`89_Tic-Tac-Toe/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`89_Tic-Tac-Toe/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`89_Tic-Tac-Toe/rust/README.md`) README.md Original source downloaded from Vintage Basic Conversion to Rust --- ### Overview (`89_Tic-Tac-Toe/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`90_Tower/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`90_Tower/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`90_Tower/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`90_Tower/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`90_Tower/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`90_Tower/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`90_Tower/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`90_Tower/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`90_Tower/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`91_Train/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`91_Train/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`91_Train/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`91_Train/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`91_Train/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`91_Train/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`91_Train/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`91_Train/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`91_Train/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`91_Train/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`92_Trap/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`92_Trap/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`92_Trap/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`92_Trap/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`92_Trap/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`92_Trap/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`92_Trap/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`92_Trap/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`92_Trap/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Uğur Küpeli [ugurkupeli](https://github.com/ugurkupeli) --- ### Overview (`92_Trap/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`93_23_Matches/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`93_23_Matches/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`93_23_Matches/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`93_23_Matches/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`93_23_Matches/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`93_23_Matches/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`93_23_Matches/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`93_23_Matches/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [rust](https://www.rust-lang.org/) --- ### Overview (`93_23_Matches/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`94_War/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`94_War/d/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html) Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo). ## Running the code Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler: ```shell dmd -preview=dip1000 -run war.d ``` [Other compilers](https://dlang.org/download.html) also exist. ## Specialties explained This game code contains some specialties that you might want to know more about. Here goes. ### Suits Most modern consoles are capable of displaying more than just ASCII, and so I have chosen to display the actual ♠, ♥, ♦ and ♣ instead of substituting them by letters like the BASIC original did. Only the Windows console needs a nudge in the right direction with these instructions: ```d SetConsoleOutputCP(CP_UTF8); // Set code page SetConsoleOutputCP(GetACP); // Restore the default ``` Instead of cluttering the `main()` function with these lesser important details, we can move them into a [module constructor and module destructor](https://dlang.org/spec/module.html#staticorder), which run before and after `main()` respectively. And because order of declaration is irrelevant in a D module, we can push those all the way down to the bottom of the file. This is of course only necessary on Windows (and won't even work anywhere else) so we'll need to wrap this in a `version (Windows)` conditional code block: ```d version (Windows) { import core.sys.windows.windows; shared static this() @trusted { SetConsoleOutputCP(CP_UTF8); } shared static ~this() @trusted { SetConsoleOutputCP(GetACP); } } ``` Although it doesn't matter much in this single-threaded program, the `shared` attribute makes that these constructors/destructors are run once per program invocation; non-shared module constructors and module destructors are run for every thread. The `@trusted` annotation is necessary because these are system API calls; The compiler cannot check these for memory-safety, and so we must indicate that we have reviewed the safety manually. ### Uniform Function Call Syntax In case you wonder why this line works: ```d if ("Do you want instructions?".yes) // ... ``` then it is because this is equivalent to ```d if (yes("Do you want instructions?")) // ... ``` where `yes()` is a Boolean function that is defined below `main()`. This is made possible by the language feature that is called [uniform function call syntax (UFCS)](https://dlang.org/spec/function.html#pseudo-member). UFCS works by passing what is in front of the dot as the first parameter to the function, and it was invented to make it possible to call free functions on objects as if they were member functions. UFCS can also be used to obtain a more natural order of function calls, such as this line inside `yes()`: ```d return trustedReadln.strip.toLower.startsWith("y"); ``` which reads easier than the equivalent ```d return startsWith(toLower(strip(trustedReadln())), "y"); ``` ### Type a lot or not? It would have been straight forward to define the `cards` array explicitly like so: ```d const cards = ["2♠", "2♥", "2♦", "2♣", "3♠", "3♥", "3♦", "3♣", "4♠", "4♥", "4♦", "4♣", "5♠", "5♥", "5♦", "5♣", "6♠", "6♥", "6♦", "6♣", "7♠", "7♥", "7♦", "7♣", "8♠", "8♥", "8♦", "8♣", "9♠", "9♥", "9♦", "9♣", "10♠", "10♥", "10♦", "10♣", "J♥", "J♦", "J♣", "J♣", "Q♠", "Q♥", "Q♦", "Q♣", "K♠", "K♥", "K♦", "K♣", "A♠", "A♥", "A♦", "A♣"]; ``` but that's tedious, difficult to spot errors in (*can you?*) and looks like something a computer can automate. Indeed it can: ```d static const cards = cartesianProduct(["2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"], ["♠", "♥", "♦", "♣"]).map!(a => a.expand.only.join).array; ``` The function [`cartesianProduct`](https://dlang.org/phobos/std_algorithm_setops.html#cartesianProduct) takes two ranges, like the horizontal and vertical headers of a spreadsheet, and fills the table with the combinations that form the coordinates of the cells. But the output of that function is in the form of an array of [`Tuple`](https://dlang.org/phobos/std_typecons.html#Tuple)s, which looks like `[Tuple!(string, string)("2", "♠"), Tuple!(string, string)("2", "♥"), ... etc]`. [`map`](https://dlang.org/phobos/std_algorithm_iteration.html#map) comes to the rescue, converting each Tuple to a string, by calling [`expand`](https://dlang.org/phobos/std_typecons.html#.Tuple.expand), then [`only`](https://dlang.org/phobos/std_range.html#only) and then [`join`](https://dlang.org/phobos/std_array.html#join) on them. The result is a lazily evaluated range of strings. Finally, [`array`](https://dlang.org/phobos/std_array.html#array) turns the range into a random access array. The `static` attribute makes that all this is performed at compile-time, so the result is exactly the same as the manually entered data, but without the typo's. ### Shuffle the cards or not? The original BASIC code works with a constant array of cards, ordered by increasing numerical value, and indexing it with indices that have been shuffled. This is efficient because in comparing who wins, the indices can be compared directly, since a higher index correlates to a card with a higher numerical value (when divided by the number of suits, 4). Some of the other reimplementations in other languages have been written in a lesser efficient way by shuffling the array of cards itself. This then requires the use of a lookup table or searching for equality in an auxiliary array when comparing cards. I find the original more elegant, so that's what you see here: ```d const indices = iota(0, cards.length).array.randomShuffle; ``` [`iota`](https://dlang.org/phobos/std_range.html#iota) produces a range of integers, in this case starting at 0 and increasing up to the number of cards in the deck (exclusive). [`array`](https://dlang.org/phobos/std_array.html#array) turns the range into an array, so that [`randomShuffle`](https://dlang.org/phobos/std_random.html#randomShuffle) can do its work. --- ### Overview (`94_War/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`94_War/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`94_War/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`94_War/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`94_War/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`94_War/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`94_War/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`94_War/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`94_War/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`95_Weekday/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`95_Weekday/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`95_Weekday/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`95_Weekday/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`95_Weekday/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`95_Weekday/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) I have replaced the manual date logic with Perl built-ins to the extent possible. Unfortunately the kind of date math involved in the "time spent doing ..." functionality is not well-defined, so I have been forced to retain the original logic here. Sigh. You can use any punctuation character you please in the date input. So something like 2/29/2020 is perfectly acceptable. It would also have been nice to produce a localized version that supports day/month/year or year-month-day input, but that didn't happen. Also nice would have been language-specific output -- especially if it could have accommodated regional differences in which day of the week or month is unlucky. Tom Wyant --- ### Overview (`95_Weekday/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`95_Weekday/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`95_Weekday/rust/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Rust](https://www.rust-lang.org/) by Anthony Rubick [AnthonyMichaelTDM](https://github.com/AnthonyMichaelTDM) --- ### Overview (`95_Weekday/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`96_Word/csharp/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Microsoft C#](https://docs.microsoft.com/en-us/dotnet/csharp/) --- ### Overview (`96_Word/d/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html) Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo). The Basic original required words to be exactly five letters in length for the program to behave correctly. This version does not replicate that limitation, and the test for that requirement is commented out. ## Running the code Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler: ```shell dmd -dip1000 -run word.d ``` [Other compilers](https://dlang.org/download.html) also exist. --- ### Overview (`96_Word/java/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Oracle Java](https://openjdk.java.net/) --- ### Overview (`96_Word/javascript/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Shells) --- ### Overview (`96_Word/kotlin/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Kotlin](https://kotlinlang.org/) --- ### Overview (`96_Word/lua/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Lua](https://www.lua.org/) --- ### Overview (`96_Word/perl/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Perl](https://www.perl.org/) --- ### Overview (`96_Word/python/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Python](https://www.python.org/about/) --- ### Overview (`96_Word/ruby/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Ruby](https://www.ruby-lang.org/en/) --- ### Overview (`96_Word/vbnet/README.md`) Original BASIC source [downloaded from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Visual Basic .NET](https://en.wikipedia.org/wiki/Visual_Basic_.NET) --- ### Overview (`00_Alternate_Languages/01_Acey_Ducey/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript aceyducey.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "aceyducey" run ``` --- ### Overview (`00_Alternate_Languages/01_Acey_Ducey/c++/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [C++14](https://en.wikipedia.org/wiki/C%2B%2B14) The build folder are executables for x86 and x64 systems. Compiled and built using Visual Studio. --- ### Overview (`00_Alternate_Languages/01_Acey_Ducey/d/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html) Converted to [D](https://dlang.org/) by [Bastiaan Veelo](https://github.com/veelo). Two versions are supplied that are functionally equivalent, but differ in source layout:
aceyducey_literal.d
A largely literal transcription of the original Basic source. All unnecessary uglyness is preserved.
aceyducey.d
An idiomatic D refactoring of the original, with a focus on increasing the readability and robustness. Memory-safety is ensured by the language, thanks to the @safe annotation.
## Running the code Assuming the reference [dmd](https://dlang.org/download.html#dmd) compiler: ```shell dmd -run aceyducey.d ``` [Other compilers](https://dlang.org/download.html) also exist. Note that there are compiler switches related to memory-safety (`-preview=dip25` and `-preview=dip1000`) that are not used here because they are unnecessary in this case. What these do is to make the analysis more thorough, so that with them some code that needed to be `@system` can then be inferred to be in fact `@safe`. [Code that compiles without these switches is just as safe as when compiled with them] (https://forum.dlang.org/post/dftgjalswvwfjpyushgn@forum.dlang.org). --- ### Overview (`00_Alternate_Languages/01_Acey_Ducey/elm/README.md`) # Acey Ducey This is an Elm implementation of the `Basic Compouter Games` Game Acey Ducey. ## Build App - install elm ```bash yarn yarn build ``` --- ### Overview (`00_Alternate_Languages/01_Acey_Ducey/pascal/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) by Gustavo Carreno [gcarreno@github](https://github.com/gcarreno) --- ### Overview (`00_Alternate_Languages/02_Amazing/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript amazing.ms ``` Note that because this program imports "listUtil", you will need to have a the standard MiniScript libraries somewhere in your import path. 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "amazing" run ``` --- ### Overview (`00_Alternate_Languages/02_Amazing/pascal/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) by Gustavo Carreno [gcarreno@github](https://github.com/gcarreno) --- ### Overview (`00_Alternate_Languages/03_Animal/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript animal.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "animal" run ``` --- ### Overview (`00_Alternate_Languages/04_Awari/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript awari.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "awari" run ``` --- ### Overview (`00_Alternate_Languages/04_Awari/elm/README.md`) # Awari This is an Elm implementation of the `Basic Compouter Games` Game Awari. ## Build App - install elm ```bash yarn yarn build ``` --- ### Overview (`00_Alternate_Languages/05_Bagels/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bagels.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bagels" run ``` --- ### Overview (`00_Alternate_Languages/06_Banner/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript banner.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "banner" run ``` --- ### Overview (`00_Alternate_Languages/07_Basketball/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript basketball.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "basketball" run ``` --- ### Overview (`00_Alternate_Languages/08_Batnum/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript batnum.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "batnum" run ``` --- ### Overview (`00_Alternate_Languages/09_Battle/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). NOTE: One feature has been added to the original game. At the "??" prompt, instead of entering coordinates, you can enter "?" (a question mark) to reprint the fleet disposition code. Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript battle.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "battle" run ``` --- ### Overview (`00_Alternate_Languages/10_Blackjack/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript blackjack.ms ``` But note that the current release (1.2.1) of command-line MiniScript does not properly flush the output buffer when line breaks are suppressed, as this program does when prompting for your next action after a Hit. So, method 2 (below) is recommended for now. 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "blackjack" run ``` --- ### Overview (`00_Alternate_Languages/10_Blackjack/pascal/README.md`) Original source downloaded [from Vintage Basic](http://www.vintage-basic.net/games.html) Conversion to [Pascal](https://en.wikipedia.org/wiki/Pascal_(programming_language)) --- ### Overview (`00_Alternate_Languages/11_Bombardment/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bombardment.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bombardment" run ``` --- ### Overview (`00_Alternate_Languages/12_Bombs_Away/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bombsaway.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bombsaway" run ``` --- ### Overview (`00_Alternate_Languages/13_Bounce/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bounce.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bounce" run ``` --- ### Overview (`00_Alternate_Languages/14_Bowling/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bowling.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bowling" run ``` --- ### Overview (`00_Alternate_Languages/15_Boxing/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript boxing.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "boxing" run ``` --- ### Overview (`00_Alternate_Languages/16_Bug/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bug.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bug" run ``` --- ### Overview (`00_Alternate_Languages/17_Bullfight/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bull.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bull" run ``` --- ### Overview (`00_Alternate_Languages/18_Bullseye/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 0. Try-It! Page: Go to https://miniscript.org/tryit/, clear the sample code from the code editor, and paste in the contents of bullseye.ms. Then click the "Run Script" button. Program output (and input) will appear in the green-on-black terminal display to the right of or below the code editor. 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bullseye.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bullseye" run ``` --- ### Overview (`00_Alternate_Languages/19_Bunny/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 0. Try-It! Page: Go to https://miniscript.org/tryit/, clear the sample code from the code editor, and paste in the contents of bunny.ms. Then click the "Run Script" button. Program output (and input) will appear in the green-on-black terminal display to the right of or below the code editor. 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bunny.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bunny" run ``` --- ### Overview (`00_Alternate_Languages/20_Buzzword/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 0. Try-It! Page: Go to https://miniscript.org/tryit/, clear the sample code from the code editor, and paste in the contents of bunny.ms. Then click the "Run Script" button. Program output (and input) will appear in the green-on-black terminal display to the right of or below the code editor. 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript bunny.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "bunny" run ``` --- ### Overview (`00_Alternate_Languages/21_Calendar/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript calendar.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "calendar" run ``` --- ### Overview (`00_Alternate_Languages/22_Change/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 0. Try-It! Page: Go to https://miniscript.org/tryit/, clear the sample code from the code editor, and paste in the contents of change.ms. Then click the "Run Script" button. Program output (and input) will appear in the green-on-black terminal display to the right of or below the code editor. 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript change.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "change" run ``` --- ### Overview (`00_Alternate_Languages/23_Checkers/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript checkers.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "checkers" run ``` --- ### Overview (`00_Alternate_Languages/24_Chemist/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 0. Try-It! Page: Go to https://miniscript.org/tryit/, clear the sample code from the code editor, and paste in the contents of chemist.ms. Then click the "Run Script" button. Program output (and input) will appear in the green-on-black terminal display to the right of or below the code editor. 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript chemist.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "chemist" run ``` --- ### Overview (`00_Alternate_Languages/25_Chief/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). NOTE: I have added `wait` statements before and while printing the lightning bolt, without which it appears too quickly to be properly dramatic. Ways to play: 0. Try-It! Page: Go to https://miniscript.org/tryit/, clear the sample code from the code editor, and paste in the contents of chief.ms. Then click the "Run Script" button. Program output (and input) will appear in the green-on-black terminal display to the right of or below the code editor. 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript chief.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "chief" run ``` --- ### Overview (`00_Alternate_Languages/26_Chomp/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript chomp.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "chomp" run ``` --- ### Overview (`00_Alternate_Languages/27_Civil_War/MiniScript/README.md`) Original source downloaded from [Vintage Basic](http://www.vintage-basic.net/games.html). Conversion to [MiniScript](https://miniscript.org). Ways to play: 1. Command-Line MiniScript: Download for your system from https://miniscript.org/cmdline/, install, and then run the program with a command such as: ``` miniscript civilwar.ms ``` 2. Mini Micro: Download Mini Micro from https://miniscript.org/MiniMicro/, launch, and then click the top disk slot and chose "Mount Folder..." Select the folder containing the MiniScript program and this README file. Then, at the Mini Micro command prompt, enter: ``` load "civilwar" run ``` --- --- METRICS --- - Files Extracted: 1141 - Estimated Token Budget: ~125029 tokens - Canonical Reference: https://codewiki.google/github.com/coding-horror/basic-computer-games