coding-horror/basic-computer-games
38.3
Weak · 12 November 2026
92.8k
lines of production code
C#
with JavaScript, Vba, Java, Python, Rust, Perl
6
measurements over time
What this system is
Features
Add 3D Plot port in MiniScript and D
Users can now run the 3D Plot program in MiniScript and D. The MiniScript version provides a direct translation of the original BASIC logic, while the D port includes a standard implementation and a bonus variant that randomly selects and plots different mathematical functions.
_00\_Alternate\_Languages/87\_3-D\Plot · high confidence
Add Acey Ducey BASIC game and documentation
This change introduces the Acey Ducey card game, originally from Basic Computer Games (1978), as a new playable entry in the collection. The update adds the source code (aceyducey.bas) and a README file that explains the betting mechanics, lists known bugs (such as the negative bet exploit), and provides porting notes and links to other language implementations.
_01\_Acey\Ducey · high confidence
Add Acey Ducey card game simulation
An Elixir implementation of the classic Acey Ducey card game has been added. Users can now run the simulation via \mix run acey\_ducey.exs\, where they start with $100 and bet on whether the next card dealt will fall between two previously revealed cards. The game handles deck shuffling automatically when cards run low and re-prompts for valid integer bets.
_01\_Acey\Ducey/elixir · high confidence
Add Awari game ports in MiniScript and Elm
New alternate-language implementations of the Awari board game have been added to the 00\_Alternate\_Languages/04\_Awari directory. This includes a MiniScript port (awari.ms) with command-line and Mini Micro execution instructions, and an Elm port (elm/) featuring a browser-based UI with player-vs-player gameplay, board visualization, and restart functionality.
_00\_Alternate\_Languages/04\Awari · high confidence
Add Basketball game simulation
Added a new interactive basketball game simulation where the user plays as the Dartmouth captain, choosing from four shot types (Long Jump, Short Jump, Lay Up, Set Shot) and four defense alignments (Press, Man-to-man, Zone, None) against a chosen opponent. The game includes porting notes documenting specific behavioral differences from the original BASIC source, such as changes to initial defense selection flow and the preservation of an unvalidated defense selection bug.
_07\Basketball · high confidence
Add Battle (Battleship) game ports in C\#, Java, JavaScript, Python, and VB.NET
This change introduces new implementations of the classic 'Battle' (Battleship) game, originally from Basic Computer Games (1978), across multiple languages. The diff adds full source code and project files for C\# (including a .sln and Game.cs), Java (Battle.java, Ship.java, Sea.java, Input.java), JavaScript (battle.js and battle.html), Python (battle.py), and Visual Basic .NET (including a .sln). Each port replicates the original game logic: a 6x6 grid, random placement of two destroyers, two cruisers, and two aircraft carriers, and a user interface for targeting coordinates to sink ships. README files are also added for each language, noting the source and the target language.
_09\Battle · high confidence
Add Blackjack port to C\#
A new C\# implementation of the Blackjack game has been added to the 10\_Blackjack directory. This port includes the full game logic (Game, Hand, Player, Deck, Card classes) and a console-based user interface (Program, Prompt) that supports standard Blackjack features such as betting, hitting, standing, doubling down, splitting hands, and insurance bets. A Visual Studio solution file (Blackjack.sln) is also provided to build the project.
_10\_Blackjack, 88\_3-D\Tic-Tac-Toe · high confidence
Add Bowling game ports for C\#, Java, JavaScript, Perl, Python, and VB.NET
This change introduces new implementations of the classic 1978 'Bowling' game for C\#, Java, JavaScript, Perl, Python, and Visual Basic .NET. Each port faithfully reproduces the original BASIC game's behavior, including the specific pin-diagram display, roll analysis messages (GUTTER, STRIKE, SPARE, ERROR), and the original scoring quirks documented in the README. The Perl port additionally offers an 'advanced' mode via the \-a\ flag that improves the visual representation of pins and displays running scores. The Python port also adds the capability to assign custom names to players.
_14\_Bowling, 42\Gunner · high confidence
Add Bullseye game ported to C\#, JavaScript, Perl, Python, Ruby, Rust, and VB.NET
This change introduces the Bullseye darts game (originally from Basic Computer Games, 1978) with new implementations in C\#, JavaScript, Perl, Python, Ruby, Rust, and Visual Basic .NET, alongside the original BASIC source. The game allows up to 20 players to throw darts at 10, 20, 30, and 40-point zones, with the objective of reaching 200 points. Each language implementation includes its respective project structure (e.g., .sln/.csproj for C\#, .sln/.vbproj for VB.NET, src/lib.rs and src/main.rs for Rust) and README files documenting the conversion source.
_18\Bullseye · high confidence
Add C\# and Visual Basic .NET ports for the Dice simulation
Users can now run the Dice frequency simulation in C\# and Visual Basic .NET. The C\# port includes a solution file, a main program entry point, a game loop class, and a dedicated roll generator, while the VB.NET port provides a corresponding solution file and program module. These additions expand the available language options for this classic 1978 simulation alongside the existing Python, JavaScript, Rust, Lua, Ruby, and Perl implementations.
_33\Dice · high confidence
Add C\# implementation of the Awari board game
This change introduces a new C\# console application for the traditional board game Awari. It includes the core game logic in \Game.cs\, handling state transitions, move validation, and a computer opponent that uses a scoring algorithm to determine moves. The \Program.cs\ file provides a text-based user interface for playing against the computer, displaying the board state, and announcing the final outcome (win, loss, or draw).
_04\Awari/csharp · high confidence
Add C\# implementation of the Bombardment game
A new C\# version of the classic 'Bombardment' game has been added to the collection. This implementation replicates the original 1970s BASIC game logic, allowing users to play a turn-based battle where they place four platoons on a grid and attempt to destroy the computer's platoons by firing missiles. The entry includes the source code, a Visual Studio solution file, and a README noting the conversion from the original Vintage Basic source.
_11\Bombardment/csharp · high confidence
Add C\# port of Hurkle game with View/ViewModel architecture
A new C\# implementation of the Hurkle game has been added to the 51\_Hurkle directory, featuring a structured solution (Hurkle.sln) and project file. This port introduces a View/ViewModel/Controller pattern to separate the console user interface (ConsoleHurkleView) from the core game logic (HurkleGame), utilizing specific ViewModel classes (GuessViewModel, FailedGuessViewModel, VictoryViewModel, LossViewModel) and an IHurkleView interface to manage state and display output.
_51\Hurkle · high confidence
Add C\# port of the Golf game
A new C\# implementation of the classic 1978 'Golf' game has been added to the 39\_Golf directory. This port targets .NET Core 3.1 and includes the source code (Program.cs), a Visual Studio solution file (Golf.sln), and documentation. The game simulates an 18-hole championship layout where players manage a handicap, select clubs, and navigate hazards like rough, trees, and water using text-based input.
(repo-wide) · high confidence
Add Calendar game ports in C\#, Java, JavaScript, Python, Ruby, Rust, and VB.NET
The 21\_Calendar location now includes new language implementations of the classic 1978 BASIC calendar game. In addition to the original \calendar.bas\, the directory now contains full source code and project files for C\# (\csharp/\), Java (\java/\), JavaScript (\javascript/\), Python (\python/\), Ruby (\ruby/\), Rust (\rust/\), and Visual Basic .NET (\vbnet/\). Most ports faithfully replicate the original hardcoded 1979 behavior, while the Python and Ruby versions add interactive prompts for the starting day of the week and leap year status, and the Perl version (also present) uses modern time libraries to support any year.
_21\Calendar · high confidence
Add Chomp game ported to C\#, Java, JavaScript, Perl, Python, and VB.NET
This change introduces the Chomp game, originally from Basic Computer Games (1978), across multiple new language implementations. The directory now includes a root README with porting notes, the original BASIC source (chomp.bas), and new ports in C\# (using embedded resources and a structured Game/Cookie model), Java, JavaScript (with a terminal-style HTML interface), Perl, Python, and Visual Basic .NET. Each port replicates the original interactive gameplay where players take turns chomping a grid-based cookie, with the player forced to take the poison square losing.
_26\Chomp · high confidence
Add Elm implementation of the Acey Ducey card game
This change introduces a new Elm-based implementation of the Acey Ducey card game, located in the \00\_Alternate\_Languages/01\_Acey\_Ducey/elm\ directory. The project includes the source code (\src/Main.elm\), build configuration (\elm.json\ with Elm 0.19.1 and standard libraries), and pre-built distribution files (\docs/app.js\, \docs/app.min.js\, \docs/index.html\) for immediate browser use. The game logic allows players to bet on whether a third card's value falls between two dealt cards, managing game state such as money, current cards, and betting amounts.
_00\_Alternate\_Languages/01\_Acey\_Ducey/elm, 01\_Acey\Ducey/python · high confidence
Add Even Wins game implementation
A new Rust implementation of the 'Even Wins' game has been added, allowing users to play a two-player marble game against a computer opponent. The game starts with 27 marbles, and players alternate taking 1 to 4 marbles; the winner is the player holding an even number of marbles when the pile is empty. The entry includes the full game logic, human input handling, and a computer AI strategy.
_13\_Bounce/ruby, 35\_Even\_Wins/rust, 43\Hammurabi/perl · high confidence
Add Gomoko game ports in Python, Java, JavaScript, Perl, C\#, VB.NET, Kotlin, Lua, and Ruby
This change introduces the Gomoko game (a variant of Gomoku) across multiple programming languages. The diff adds source files and project configurations for Python (Gomoko.py), Java (Gomoko.java), JavaScript (gomoko.js with an HTML shell), Perl (gomoko.pl), C\# (Gomoko.csproj/sln), Visual Basic .NET (Gomoko.vbproj/sln), Kotlin, Lua, and Ruby. Each port implements the original 1978 BASIC logic: a two-player game on an N×N grid (7-19) where players place markers to get five in a row, with the computer using a simple heuristic for moves. The entry includes README files for each language citing the original source from Vintage Basic and adding a 'Porting Notes' section to the main README.
_40\Gomoko · high confidence
Add Horserace game implementations in multiple languages
Users can now play the classic 'Horserace' simulation (originally from Basic Computer Games, 1978) in Python, Java, JavaScript, C\#, Visual Basic .NET, Kotlin, Lua, Perl, and Ruby. This location provides the specific source code files, project solution files (for C\# and VB.NET), and README documentation for each of these language ports, allowing users to run the horse betting and race simulation in their preferred environment.
_47\_Hi-Lo, 50\Horserace · high confidence
Add Java implementation for the Buzzword exercise
A new Java source file (src/Buzzword.java) has been added to the 20\_Buzzword exercise. This entry point initializes a Scanner for input, creates a BuzzwordSupplier and a UserInterface, and starts the application by calling userInterface.run().
_20\Buzzword/java · high confidence
Add JavaScript port of the Bagels guessing game
A new JavaScript implementation of the classic Bagels number-guessing game has been added to the repository. This includes the core game logic in bagels.js, a corresponding HTML page (bagels.html) that loads the script and applies a terminal-style CSS theme, and a README documenting the conversion from the original Vintage Basic source.
_05\Bagels/javascript · high confidence
Add JavaScript ports of vintage text-based games
New JavaScript implementations have been added for several classic text-based games, including Animal, Awari, Basketball, Batnum, Bombardment, and Bounce. These ports, converted from their original BASIC sources, run in the browser using a shared terminal-style stylesheet and provide interactive gameplay via HTML pages and associated JavaScript logic.
(repo-wide) · high confidence
Add Literature Quiz port to Rust
A new Rust implementation of the Literature Quiz game has been added to the 57\_Literature\_Quiz directory. This port includes the source code in src/main.rs and a README.md, allowing users to run the quiz using the Rust toolchain.
_57\_Literature\Quiz · high confidence
Add MiniScript port of 3-D Tic-Tac-Toe
Users can now play the 3-D Tic-Tac-Toe (Qubic) game using MiniScript. This change adds the \qubit.ms\ source file and a \README.md\ with instructions for running the game via Command-Line MiniScript or Mini Micro. A parent \README.md\ is also added to clarify the purpose of the alternate language folder.
_00\_Alternate\_Languages/88\_3-D\Tic-Tac-Toe · high confidence
Add MiniScript port of Mastermind game
Users can now play the Mastermind game using MiniScript. This change adds a new \MiniScript\ subfolder within the \00\_Alternate\_Languages/60\_Mastermind\ directory, containing the \mastermind.ms\ source code and a \README.md\ with instructions for running the game via Command-Line MiniScript or Mini Micro. The implementation is a direct conversion of the original Vintage Basic source, preserving the standard gameplay mechanics where users guess a secret code and the computer attempts to guess a user-defined code.
(repo-wide) · high confidence
Add MiniScript port of the 3D Target shooting game
Users can now play the classic 3D target shooting game using MiniScript. This change adds a new \MiniScript\ subfolder containing the \target.ms\ source file and a \README.md\ with instructions for running the game via Command-Line MiniScript or Mini Micro.
_00\_Alternate\_Languages/86\Target · high confidence
Add MiniScript, Pascal, and Basic ports of Tic-Tac-Toe
New language ports for the Tic-Tac-Toe game have been added to the Alternate Languages collection. This includes two MiniScript implementations (tictactoe.ms and tictactoe2.ms) with a README explaining how to run them via command-line MiniScript or Mini Micro, a Pascal port (tictactoe1.pas), and two Basic versions (tictactoe1.bas and tictactoe2.bas). These files provide educational examples of the game logic in these specific scripting languages.
_00\_Alternate\_Languages/89\Tic-Tac-Toe · high confidence
Add Nim implementation of the Train speed/distance exercise
A new Nim port of the 'Train' interactive problem has been added to the alternate languages collection. This implementation allows users to solve a time-speed-distance word problem by calculating the car's travel time based on given speed and time-difference parameters, providing feedback on the accuracy of their guess.
_00\_Alternate\_Languages/91\Train/nim · high confidence
Add Nim port for the Bagels number guessing game
A new Nim implementation of the Bagels game has been added to the repository. This port allows users to play the classic number guessing game using the Nim language, featuring logic for generating unique random digits, validating three-digit inputs, and providing PICO, FERMI, and BAGELS clues based on the user's guesses.
_00\_Alternate\_Languages/05\Bagels/nim · high confidence
Add Russian Roulette game ported to multiple languages
Adds the classic 'Russian Roulette' game (originally from Basic Computer Games, 1978) to the collection, with implementations in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, VB.NET, and the original BASIC. The game simulates a revolver with one bullet and five empty chambers; players spin the chamber and pull the trigger by inputting '1', or quit by inputting '2'. Users win if they survive ten rounds. The JavaScript version includes a terminal-style HTML interface, and all language folders contain README files documenting the source and conversion details.
_37\_Football, 76\_Russian\Roulette · high confidence
Add Rust implementation of the Bounce game simulation
A new Rust source file (src/main.rs) has been added to the 13\_Bounce directory, providing a direct translation of the classic BASIC Bounce game. This implementation allows users to simulate a ball thrown straight up by specifying the initial velocity, coefficient of elasticity, and time increment, displaying the ball's trajectory in the terminal.
_13\Bounce/rust · high confidence
Add Rust implementation of the FlipFlop puzzle game
The Rust port of the FlipFlop puzzle game is now available, allowing users to play the classic logic challenge where they must flip a row of ten characters from 'X' to 'O' by entering position numbers. The implementation uses the \morristown\ library for input handling and \rand\ for game initialization, featuring a loop-based gameplay that tracks tries and provides feedback on performance.
_36\_Flip\Flop/rust · high confidence
Add Rust implementation of the Guess number game
A new Rust version of the 'Guess' game has been added to the 41\_Guess collection. This implementation allows users to set a numerical limit, after which the computer selects a random number within that range for the user to guess. The program provides feedback ('Too low' or 'Too high') and tracks the number of attempts, comparing the user's performance against an optimal binary-search-based target to offer a final rating.
_41\Guess/rust · high confidence
Add Rust implementation of the King text-based strategy game
A new Rust-based version of the classic King game has been added to the project. This implementation replicates the original game's round-based mechanics, allowing users to manage resources like money, land, and workers over an eight-year term. The entry point is a new \src/main.rs\ file that handles the game loop, state management, and terminal input/output, relying on the \fastrand\ library for random number generation.
_53\King/rust · high confidence
Add Rust port of 42\_Gunner
A new Rust implementation of the 42\_Gunner game has been added, allowing users to play the classic artillery simulation in this language. The port replicates the original game logic, including random target placement, elevation input validation, and hit/miss feedback, providing a native Rust experience for this specific exercise.
_42\Gunner/rust · high confidence
Add Rust port of the 'Hello' interactive game
A new Rust implementation of the classic 'Hello' interactive game has been added to the 45\_Hello directory. This program allows users to input their name and select problem categories (Sex, Health, Money, or Job) to receive humorous, text-based advice, faithfully translating the original BASIC logic into Rust.
_45\Hello/rust · high confidence
Add Rust port of the Bagels game
A new Rust implementation of the classic Bagels number-guessing game has been added to the 05\_Bagels directory. Users can now play the game, which involves guessing a three-digit number with unique digits and receiving clues (Pico, Fermi, or Bagels), directly within the Rust environment. The port includes the full game loop, input validation, and scoring logic, sourced from the original Vintage Basic version.
(repo-wide) · high confidence
Add Swift implementation of the Creative Computing 'Hello' interactive program
A new Swift source file (hello.swift) has been added to the 00\_Alternate\_Languages/45\_Hello/Swift directory, providing a port of the classic Creative Computing interactive text adventure. This program allows users to input their name and receive humorous advice on topics such as job, money, health, and sex, replicating the behavior of the original BASIC version in Swift.
_00\_Alternate\_Languages/45\Hello/Swift · high confidence
Add Tower of Hanoi game port to MiniScript
A new port of the classic Tower of Hanoi puzzle has been added to the Alternate Languages collection, implemented in MiniScript. This entry includes the game source code (tower.ms) and a README explaining how to run the program via the MiniScript command-line interface or within the Mini Micro environment.
_00\_Alternate\_Languages/90\Tower · high confidence
Add Visual Basic .NET implementation of Acey Ducey
A new Visual Basic .NET port of the classic Acey Ducey card game has been added to the repository. The implementation modernizes the original BASIC logic by replacing GOTO statements with structured Do/Loop constructs and organizing the code into subroutines and functions. Users can now play the game, which manages a player balance and wagering logic, using the .NET Random class for card generation.
_01\_Acey\Ducey/vbnet · high confidence
Add Visual Basic .NET port of the Batnum game
A new Visual Basic .NET implementation of the classic 'Battle of Numbers' (Batnum) game has been added to the 08\_Batnum/vbnet directory. This port includes the main application logic in Program.vb, a Visual Studio solution file (batnum.sln), and a README documenting the conversion from the original BASIC source. Users can now build and run the game using modern .NET tooling.
_08\Batnum/vbnet · high confidence
Add new language ports for the Sine Wave demo
The 78\_Sine\_Wave location now includes implementations in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, alongside the original BASIC source. Each port reproduces the classic 1978 'Sine Wave' terminal animation (alternating 'Creative' and 'Computing' text) and includes a README noting the conversion to that specific language.
_78\_Sine\Wave · high confidence
Added 3D Plot game implementation in Rust
A new Rust implementation of the classic '3D Plot' game has been added to the project. This entry provides a direct translation of the original BASIC source code, allowing users to run the text-based 3D visualization using the Rust toolchain. The application generates a 3D surface plot using ASCII characters in the terminal.
_87\_3-D\Plot/rust · high confidence
Added ANSI C 'Hello' interactive game example
A new ANSI C source file (hello.c) has been added to the 00\_Alternate\_Languages/45\_Hello directory. This file implements an interactive text-based game where the user inputs their name and selects problem categories (Job, Money, Health, Sex) to receive humorous advice, concluding with a playful request for payment. The implementation uses standard C libraries for input handling and string comparison.
_00\_Alternate\_Languages/45\_Hello/ANSI\C · high confidence
Added Bagels game implementation in Kotlin
A new Kotlin implementation of the classic 'Bagels' number-guessing game has been added to the project. This console-based application allows users to guess a three-digit number with unique digits, receiving feedback in the form of 'Fermi' (correct digit, correct position), 'Pico' (correct digit, wrong position), or 'Bagels' (no correct digits). The game supports a rules explanation, input validation, and a 20-guess limit, providing a complete playable experience for users interested in this logic puzzle.
(repo-wide) · high confidence
Added Batnum game and documentation
Added the Batnum game, a 'battle of numbers' implementation in BASIC, along with its README documentation. The game allows players to remove objects from a pile with configurable minimum and maximum moves, win conditions (taking or avoiding the last object), and turn order. The entry includes the source code (batnum.bas) and descriptive text explaining the modulo arithmetic strategy and historical context from Basic Computer Games (1978).
_08\Batnum · high confidence
Added Bombs Away game in C\#
Introduced a new C\# implementation of the Bombs Away game, featuring a Visual Studio 2022 solution with a console user interface and a modular game engine. The game allows players to choose from four historical sides (Allies, Germany, Italy, Japan) and fly missions with varying success probabilities based on experience and enemy defenses, using modern C\# features like file-scoped namespaces.
_12\_Bombs\Away/csharp · high confidence
Added Bombs Away game ports in MiniScript, Go, and Vintage Basic
Users can now play the Bombs Away game in three additional languages: MiniScript (with instructions for both command-line and Mini Micro environments), Go, and Vintage Basic. Each port replicates the original game logic, allowing players to select a side (Italy, Allies, Japan, or Germany), choose targets or aircraft, and experience mission outcomes based on random chance and enemy defenses.
_00\_Alternate\_Languages/12\_Bombs\_Away, 00\_Alternate\_Languages/42\_Gunner, 00\_Alternate\_Languages/47\Hi-Lo · high confidence
Added C and BASIC ports for the Hello program
This location now includes two new language implementations of the Hello program: a C version (hello.c) and a BASIC version (hello.bas). The C port replicates the interactive advice-giver logic using standard I/O and string comparison functions, while the BASIC port provides a line-numbered equivalent. These additions expand the educational options for users exploring non-standard language ports within the Alternate Languages section.
_00\_Alternate\_Languages/45\Hello · high confidence
Added C and MiniScript ports for the Cube game
New implementations of the Cube game have been added in C and MiniScript, providing users with additional ways to play the classic title alongside the existing BASIC version. The C port includes platform-specific screen clearing and standard input handling, while the MiniScript port offers both command-line and Mini Micro execution modes as detailed in the new README files.
_00\_Alternate\_Languages/30\_Cube, 00\_Alternate\_Languages/44\Hangman · high confidence
Added C implementation for dice rolling simulation
A new C source file (dice.c) has been added to the project, providing a command-line tool that simulates rolling a pair of dice. Users can specify the number of rolls, after which the program outputs the frequency and percentage of each possible sum (2–12).
_00\_Alternate\_Languages/33\Dice/C · high confidence
Added C\# and Java ports of classic vintage games
New implementations of four classic games have been added: Acey Ducey (C\#), Animal (C\#), Bagels (Java), and Batnum (C\#). These ports translate original Vintage Basic source code into modern C\# and Java, providing users with playable versions of these historical titles in their preferred language.
(repo-wide) · high confidence
Added C\# implementation of the Bagels guessing game
Users can now play the classic 'Bagels' number-guessing game using the new C\# console application located in the 05\_Bagels/csharp directory. This implementation includes the core game logic for generating secret numbers and validating guesses, a command-line interface for input and feedback (Pico/Fermi clues), and a solution file to build the project.
_05\Bagels/csharp · high confidence
Added D language implementation of the Train exercise
A new D language implementation of the 'Train' exercise has been added, providing a solution for the time-speed-distance problem. This includes the source code (train.d) and a README file, allowing users to view or run the exercise in D.
_00\_Alternate\_Languages/91\Train/D · high confidence
Added Go and MiniScript ports for the Change program
Users can now run the 'Change' program in Go and MiniScript. The Go implementation provides a command-line interface that calculates change for items up to $100, handling input validation and breaking down the result into bills and coins. The MiniScript port offers the same functionality, runnable via the command line, Mini Micro, or the online Try-It! page.
_00\_Alternate\_Languages/22\Change · high confidence
Added Go implementation of the Dice simulation program
A new Go source file (main.go) has been added to the 00\_Alternate\_Languages/33\_Dice directory, providing a port of the classic Dice simulation. This implementation allows users to specify the number of dice rolls, simulates the outcomes using random number generation, and displays a frequency distribution of the results, mirroring the functionality of existing language variants in this collection.
_00\_Alternate\_Languages/33\Dice/go · high confidence
Added Go implementation of the Hello interactive game
A new Go source file (main.go) has been added to the 00\_Alternate\_Languages/45\_Hello directory, providing a Go-language version of the classic 'Hello' interactive text game. This implementation allows users to run the same conversational experience—where the computer asks for a name, offers advice on problems like health or money, and handles user input—using the Go runtime instead of other available languages.
_00\_Alternate\_Languages/45\Hello/go · high confidence
Added Java and Ruby ports of classic Creative Computing games
New Java and Ruby implementations have been added for several vintage text-based games originally from Creative Computing, including Awari, Bagels, Bombardment, Bullseye, Change, Chemist, Dice, Fur Trader, Guess, and Hammurabi. These ports replicate the original gameplay logic and user interface styles, providing users with playable versions of these classic titles in modern languages.
(repo-wide) · high confidence
Added Java implementation of the Acey Ducey card game
This location introduces a Java port of the classic Acey Ducey card game, originally sourced from Vintage Basic. The implementation includes the core game logic in \AceyDucey.java\, a driver class \AceyDuceyGame.java\ for execution, and a \Card.java\ helper class. The game simulates a betting scenario where players wager on whether a drawn card's value falls between two dealer cards, supporting gameplay until the player's cash is depleted. A README documents the source and notes that this specific version targets JDK 8/11 compatibility.
(repo-wide) · high confidence
Added Java implementation of the Cube text-based game
Introduced a new Java application that implements the 'Cube' game logic, ported from the original BASIC version. The game places the player in a 3x3x3 grid where they must navigate from location (1,1,1) to (3,3,3) while avoiding five randomly placed mines. Users can view instructions, place wagers with an initial bankroll of 500 dollars, and make moves by entering coordinate triples; illegal moves or hitting a mine result in a loss.
_30\Cube/java · high confidence
Added Java implementation of the HighIQ game
This change introduces a new Java-based implementation of the HighIQ puzzle game. The \HighIQ\ class handles the core game logic, including board initialization, move validation, and win/loss conditions, while \HighIQGame\ serves as the entry point, displaying instructions and allowing the user to replay the game. The implementation is based on the classic Basic Computer Games version.
_48\_High\IQ/java · high confidence
Added Java implementation of the Sine Wave program
Users can now run the Sine Wave exercise in Java. This new file implements the classic 1970s BASIC program logic, printing a sine wave pattern using 'CREATIVE' and 'COMPUTING' text, adhering strictly to the original behavior without adding extra features or error checking.
_78\_Sine\Wave/java · high confidence
Added Kotlin implementation of the Bullfight text game
A new Kotlin source file (Main.kt) has been added to the 17\_Bullfight/kotlin module, implementing the core logic for the Bullfight text-based game. This includes the main game loop, state management for bull quality and matador honor, random number generation abstractions, and the calculation of game outcomes based on user inputs and simulated events.
_17\_Bullfight/kotlin, 19\Bunny/rust · high confidence
Added MiniScript and Go ports of the Bombardment game
Users can now play the classic 'Bombardment' game using two new language implementations: a Go version (run via \go run main.go\) and a MiniScript version (run via \miniscript bombardment.ms\ or loaded in Mini Micro). These ports replicate the original BASIC game's mechanics, including the 5x5 outpost grid, four-platoon setup, and turn-based missile firing logic, providing additional ways to experience the educational exercise.
(repo-wide) · high confidence
Added MiniScript and Pascal ports for Math Dice
Users can now run the Math Dice game in MiniScript and Pascal. The MiniScript port includes a script (mathdice.ms) and instructions for running it via the web try-it page, command-line, or Mini Micro. The Pascal port provides a source file (mathdice.pas) compatible with Free Pascal, featuring improved input validation to handle non-numeric entries gracefully.
_00\_Alternate\_Languages/61\_Math\Dice · high confidence
Added MiniScript port for 13\_Bounce
Users can now run the 13\_Bounce simulation using MiniScript. This new port includes the source code (bounce.ms) and a README with instructions for running the program via Command-Line MiniScript or Mini Micro, providing an additional educational option alongside the existing Basic implementation.
_00\_Alternate\_Languages/13\_Bounce, 00\_Alternate\_Languages/57\_Literature\Quiz · high confidence
Added MiniScript port for the Banner program
Users can now run the Banner program using MiniScript. This change adds a new \MiniScript\ subfolder within the \00\_Alternate\_Languages/06\_Banner\ directory, containing \banner.ms\ (the source code) and \README.md\ (instructions for running via Command-Line MiniScript or Mini Micro). The implementation replicates the original Vintage Basic logic, allowing users to input horizontal/vertical block sizes, centering preference, a specific print character, and a statement to display in a giant sideways banner style.
(repo-wide) · high confidence
Added MiniScript port of the 91\_Train educational game
Users can now run the '91\_Train' time-speed-distance exercise in MiniScript. This new port includes the game logic in train.ms and a README with instructions for running the script via the web Try-It page, command-line MiniScript, or Mini Micro.
_00\_Alternate\_Languages/91\Train/MiniScript · high confidence
Added MiniScript port of the Combat game
Users can now play the 'Combat' text-based strategy game using MiniScript. This change adds a new \MiniScript\ subfolder within the \00\_Alternate\_Languages/28\_Combat\ directory, containing the \combat.ms\ source file and a \README.md\ with instructions for running the game via Command-Line MiniScript or Mini Micro. The port replicates the original Vintage Basic logic, allowing players to distribute forces and engage in army, navy, and air force battles.
(repo-wide) · high confidence
Added MiniScript port of the FlipFlop puzzle game
Users can now play the classic FlipFlop puzzle in MiniScript. This new port includes the game logic (flipflop.ms) and a README with instructions for running the game via Command-Line MiniScript or Mini Micro, providing an additional way to experience this educational puzzle.
_00\_Alternate\_Languages/36\_Flip\Flop · high confidence
Added MiniScript port of the Pizza Delivery Game
A new MiniScript implementation of the 69\_Pizza game has been added to the Alternate Languages section, including the source code (pizza.ms) and a README with instructions for running it via Command-Line MiniScript or Mini Micro. This port allows users to experience the classic Creative Computing pizza delivery logic in MiniScript, distinct from the primary language implementations.
_00\_Alternate\_Languages/69\Pizza · high confidence
Added MiniScript port of the Stock Market simulation
Users can now play the classic Stock Market simulation using MiniScript. This change adds a new subfolder under 00\_Alternate\_Languages/83\_Stock\_Market containing the source code (stockmarket.ms) and a README with instructions for running the game via Command-Line MiniScript or Mini Micro.
_00\_Alternate\_Languages/83\_Stock\Market · high confidence
Added MiniScript ports for Letter and Trap games
Users can now play the Letter guessing game and the Trap number-guessing game using MiniScript. This change introduces new \MiniScript\ subdirectories for both \54\_Letter\ and \92\_Trap\, containing the source code (\letter.ms\, \trap.ms\) and specific \README.md\ files that explain how to run the games via Command-Line MiniScript, Mini Micro, or the web-based Try-It page.
_00\_Alternate\_Languages/92\Trap · high confidence
Added MiniScript ports for Poetry and Poker games
New MiniScript implementations of the Poetry and Poker games have been added to the alternate languages collection. Users can now run these classic text-based games using either the MiniScript command-line interpreter or the Mini Micro environment, with specific instructions provided in the respective README files for each game.
_00\_Alternate\_Languages/70\Poetry · high confidence
Added MiniScript version of the Hello Creative Computing game
Users can now run the classic 'Hello Creative Computing' interactive game using MiniScript. This new entry includes the source code (hello.ms) and a README with instructions for running the program via the MiniScript command-line tool or within the Mini Micro environment.
_00\_Alternate\_Languages/45\Hello/MiniScript · high confidence
Added Nicomachus number-guessing game
A new interactive command-line game has been added that implements the 'Boomerang Puzzle' from Nicomachus's Arithmetica. The program asks the user to think of a number between 1 and 100, collects the remainders when that number is divided by 3, 5, and 7, and then uses modular arithmetic to guess the original number.
_64\Nicomachus/rust · high confidence
Added Nim implementation for the Dice exercise
A new Nim port for the Dice exercise has been added, providing a command-line simulation that rolls a pair of dice a user-specified number of times and displays the frequency distribution of the sums. The implementation seeds the random number generator, handles user input for roll count and retry logic, and correctly initializes the frequency array to ensure accurate counting across multiple rounds.
_00\_Alternate\_Languages/33\Dice/nim · high confidence
Added Perl port of the Acey-Ducey card game
Users can now play the classic Acey-Ducey card game using a new Perl implementation. The game allows players to start with $100, bet on whether the next card drawn will fall between two previously dealt cards, and continue playing until they choose to quit or run out of money. This entry includes the main game script and a README documenting the source and conversion.
_00\_Alternate\_Languages/01\_Acey\_Ducey/MiniScript, 01\_Acey\Ducey/perl · high confidence
Added Perl port of the Batnum game
This change introduces a new Perl implementation of the 'Batnum' (Battle of Numbers) game, converted from its original Vintage Basic source. The \batnum.pl\ script provides a command-line interface where users can configure game parameters such as pile size, minimum/maximum selection limits, win conditions (taking or avoiding the last item), and turn order. The game loop handles alternating turns between the player and the computer, including logic for player moves, computer moves, and termination conditions.
(repo-wide) · high confidence
Added Perl port of the Bounce simulation game
A new Perl implementation of the classic 'Bounce' simulation game has been added to the 13\_Bounce collection. This port translates the original Vintage Basic code and includes usability improvements such as input validation for the elasticity coefficient and a feature allowing users to quit the simulation by entering a time increment of 0, eliminating the need to press Control-C.
_00\_Alternate\_Languages/33\_Dice/MiniScript, 13\Bounce/perl · high confidence
Added Perl versions of the Basketball game
Added a Perl implementation of the Basketball game in the 07\_Basketball/perl directory, providing two versions: a faithful translation (basketball-orig.pl) that retains the original structure including GOTO statements, and a modern translation (basketball.pl) that restructures the code into subroutines to eliminate GOTOs while maintaining identical game logic and probabilities.
_07\Basketball/perl · high confidence
Added Python port of the Bounce physics simulation
A new Python implementation of the 'Bounce' physics simulation has been added to the 13\_Bounce directory. This port, originally from Vintage Basic, allows users to specify initial velocity, coefficient of restitution, and time increment to visualize a ball's trajectory in the terminal. The entry includes the source code (bounce.py) and a README explaining the conversion.
_13\Bounce/python · high confidence
Added Rust implementation for weekday calculation
Introduced a new Rust port for the 95\_Weekday exercise, providing a command-line tool that calculates the day of the week for a given date. The application accepts user input for month, day, and year, validates the data, and outputs the corresponding weekday name, including a special warning for Friday the 13th. It also supports calculating the time difference between two dates.
_95\Weekday/rust · high confidence
Added Rust implementation of the Towers of Hanoi game
A new Rust-based console application has been added to the \90\_Tower/rust\ directory, implementing the classic Towers of Hanoi puzzle. The game allows users to select a disk count (between 3 and 7) and interactively move disks between three needles using a text-based interface. The implementation includes core game logic in \game.rs\, disk and needle structures in \disk.rs\ and \needle.rs\, and input utilities in \util.rs\, with \main.rs\ orchestrating the game loop and instructions.
_90\Tower/rust · high confidence
Added Rust implementation of the Word guessing game
A new Rust-based version of the Word game has been added, allowing users to guess a hidden five-letter word through a series of clues. The implementation includes a main entry point, a progress tracker that displays correctly guessed letters, and a game loop that validates input (ensuring 5 ASCII alphabetic characters) and provides feedback on letter matches and positions. The game selects a random word from a predefined list and continues until the user guesses the word correctly or chooses to quit.
_96\Word/rust · high confidence
Added Rust port of the 'Animal' guessing game
A new Rust implementation of the classic 'Animal' guessing game has been added to the 03\_Animal directory. This version allows users to play the interactive game where the computer guesses an animal by asking yes/no questions and learns new animals from user input. The code includes a README crediting the original source and the Rust converter, and the main application logic is contained in src/main.rs.
_03\Animal/rust · high confidence
Added Rust port of the 'Splat' parachute simulation game
The application now includes a Rust implementation of the 'Splat' game, allowing users to simulate a parachute jump by selecting or randomizing terminal velocity and gravitational acceleration (with options for various celestial bodies). The game loop calculates freefall physics, displays real-time altitude updates, and determines if the player survives or 'splats' based on chute deployment timing. It also features a persistent stats system that saves and loads jump altitudes to rank current performance against previous successful jumps.
_81\Splat/rust · high confidence
Added Rust-based Markdown TODO list generator
A new Rust utility has been added to generate a Markdown TODO list for the repository, tracking the implementation status of various programming languages across game projects. The tool scans the repository structure, ignoring specific directories like \.git\ and \00\_Utilities\, and outputs a formatted list showing which languages (such as C\#, Java, Python, Rust, etc.) are implemented for each game, with options to format the output by game or by language.
_00\_Utilities/markdown\_todo\rust · high confidence
Added Visual Basic .NET solution and test project for Animal game
The VB.NET implementation of the Animal game now includes a complete Visual Studio solution file (Animal.sln) that defines both the main Animal project and a new Animal.Tests project using xUnit. A README has been added to document the conversion from the original BASIC source, noting that the Game class uses a console abstraction for UI flexibility and that input is normalized to uppercase.
_03\Animal/vbnet · high confidence
Added Visual Studio solution files for VB.NET exercises
Visual Studio solution files (.sln) have been added for the VB.NET exercises (Awari, Bagels, Basketball, Bombardment, Bombs Away, and Bounce). This allows users to open and build these projects directly in Visual Studio, complementing the existing README documentation that describes the conversion from original BASIC sources.
(repo-wide) · high confidence
Added alternate language ports for classic games
New source code and project files have been added for the Acey Ducey, Bagels, Dice, Tic-Tac-Toe, and Train games in the \00\_Alternate\_Languages\ directory. These include Pascal (Object Pascal and simple procedural) and D language implementations for Acey Ducey, a Go implementation for Tic-Tac-Toe, and original BASIC sources for Bagels, Dice, and Train, providing educational alternatives to the primary ten-language set.
(repo-wide) · high confidence
Added interactive diamond pattern generator
Introduced a new Rust application that renders a diamond pattern in the terminal. The program prompts the user to input an odd number between 5 and 31, then prints a bordered grid of diamond shapes using configurable characters for padding, filling, and borders.
_32\Diamond/rust · high confidence
Added new language ports for the Guess game
New implementations of the Guess game have been added for Go and MiniScript, alongside the original BASIC source. Users can now run the number-guessing game using the Go binary or via MiniScript (command-line, Mini Micro, or web try-it page), expanding the available ways to play this classic title.
_00\_Alternate\_Languages/41\Guess · high confidence
Added terminal-style CSS for JavaScript utilities
A new stylesheet (style\_terminal.css) has been added to the JavaScript utilities folder, applying a retro terminal aesthetic with a green-on-black color scheme, monospace fonts, and CRT-style visual effects like screen flicker and scanlines. This style is applied to the output and input elements, enhancing the visual presentation of terminal-based interactions within the JavaScript utilities.
_00\Utilities/javascript · high confidence
Amazing game ported to multiple languages
The Amazing maze game is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, in addition to the original BASIC version. Each port includes its own README with source attribution and, where applicable, specific run instructions (e.g., DEBUG mode in Ruby). The JavaScript version includes an HTML file with terminal styling, and the .NET ports include solution and project files for Visual Studio.
_02\_Amazing, 44\Hangman · high confidence
C\# port of Salvo with structured game logic and computer AI
The C\# implementation of the Salvo game has been introduced, providing a complete port of the classic 10x10 grid battleship variant. This version features a structured object-oriented design with dedicated classes for ships (Battleship, Cruiser, Destroyers), fleet management, and coordinate handling. A key behavioral addition is the computer opponent's targeting system, which includes a \ComputerShotSelector\ that employs a \KnownHitsShotSelectionStrategy\ to prioritize shots near previously damaged ships, alongside a \SearchPatternShotSelectionStrategy\ for initial exploration. The game loop is managed by a \TurnHandler\ that supports both human and computer turns, validates input coordinates, and tracks shot history to prevent duplicate targeting.
_77\Salvo · high confidence
Checkers ported to C\#, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and VB.NET
The Checkers game (originally from Basic Computer Games, 1978) is now available in multiple new language implementations. This location adds the C\# console application, a JavaScript version with a terminal-style HTML interface, and source files for Kotlin, Lua, Perl, Python, Ruby, and Visual Basic .NET. Each port adheres to the original game logic, including the computer's move evaluation and multi-jump mechanics, while providing language-appropriate structures and documentation.
_23\Checkers · high confidence
Civil War simulation ported to MiniScript
A new MiniScript port of the Civil War simulation game has been added to the Alternate Languages section. This includes the \civilwar.ms\ source code and a \README.md\ with instructions for running the game via Command-Line MiniScript or Mini Micro, providing an additional way to play the classic simulation.
_00\_Alternate\_Languages/27\_Civil\War · high confidence
Craps game ports added for MiniScript and Nim
New implementations of the Craps game have been added for the MiniScript and Nim languages. The MiniScript port includes a command-line version and instructions for Mini Micro, featuring a slight delay between dice rolls for dramatic effect. The Nim port replicates the original game logic, including wagering, natural wins, point establishment, and final win/loss summaries, using standard library randomization.
_00\_Alternate\_Languages/29\Craps · high confidence
Flip Flop game ports added for C\#, Java, JavaScript, Lua, Perl, Python, Ruby, and VB.NET
This location adds new language implementations of the classic 'Flip Flop' puzzle game, originally from Basic Computer Games (1978). The diff introduces source files and project configurations for C\# (FlipFlop.cs, .sln), Java (FlipFlop.java), JavaScript (flipflop.js, flipflop.html), Lua (flipflop-game.lua), Perl (flipflop.pl), Python (flipflop.py), Ruby, and Visual Basic .NET (vbnet/FlipFlop.sln). Each port faithfully recreates the original gameplay mechanics—flipping a row of ten X's to O's within 12 moves—while adapting the interface to the target language's standard input/output methods (e.g., console for C\#/Java/Python, DOM manipulation for JavaScript). The Lua port notably modernizes the random number generation by replacing the original BASIC trigonometric hacks with Lua's built-in math.random, while other ports retain the original logic or adapt it directly.
_36\_Flip\Flop · high confidence
Hexapawn ported to C\#
A new C\# implementation of the Hexapawn game has been added to the 46\_Hexapawn directory. This port translates the original BASIC logic into a structured C\# application, featuring a learning computer opponent that eliminates losing moves over a series of games, alongside standard board, move, and player classes.
_46\Hexapawn · high confidence
Initial C\# implementation of the Bounce simulation
This change introduces the C\# port of the Bounce game, originally from Vintage Basic. The application simulates a ball's trajectory by calculating height and position over time using projectile motion equations, then renders the result as a text-based graph. Users can input initial velocity, elasticity, and time increment to view the bounce sequence. The implementation uses a \Game\ class to orchestrate the loop, a \Bounce\ class for physics calculations, and a \Graph\ class to build and display the ASCII visualization.
_13\Bounce/csharp · high confidence
Initial Java port of Bombs Away with bug fixes
This change introduces a Java port of the classic 'Bombs Away' game, originally sourced from Vintage Basic. The implementation faithfully reproduces the original gameplay while applying modern Java conventions and fixing specific bugs found in the source logic, such as incorrect calculations for enemy weapon selection (guns vs. missiles) and gunner rate queries.
_12\_Bombs\Away/java · high confidence
Initial Ruby port of the Awari board game
Adds a new Ruby implementation of the Awari board game, converting the original Vintage Basic source. The code introduces a Game class to manage game state and logic, along with helper functions to mimic Vintage Basic's input and output behavior, allowing users to play the game via the command line.
_04\Awari/ruby · high confidence
Initial Rust implementation of the Reverse game
A new Rust implementation of the 'Reverse' game has been added to the 73\_Reverse/rust directory. This is a direct translation of the original BASIC version, allowing users to play the same logic puzzle where they must sort a list of numbers by reversing prefixes. The game generates a random list of 9 unique numbers and prompts the user to specify how many numbers from the left to reverse in each turn, with the goal of arranging them in numerical order.
_63\_Name/rust, 73\Reverse/rust · high confidence
Initial Rust port of the Blackjack game
Added a new Rust implementation of the Blackjack game in the \10\_Blackjack/rust\ directory. This entry point introduces the core game logic, including card handling, deck management with shuffling, and player/dealer state tracking. The initial version supports basic gameplay actions such as hitting, standing, doubling down, and splitting, along with betting mechanics and balance tracking.
_10\Blackjack/rust · high confidence
Initial release of Conway's Game of Life in Rust
A new Rust implementation of the 'Basic Computer Games' version of Conway's Game of Life has been added to the project. The application runs on a fixed 24x70 grid, accepting user-defined patterns via standard input and simulating generations until the population dies out. It features bounds checking for input lines, uses an enum for cell states (Empty, Alive, AboutToDie, AboutToBeBorn) to manage transitions, and displays the board using specific characters for each state (\*, space, o, .).
_55\Life/rust · high confidence
Initial release of the 3D Cube text-based game
This change introduces the core Rust implementation for the 'Cube' game, a text-based adventure where players navigate a 3x3x3 grid to reach the destination (3,3,3) while avoiding randomly placed landmines. The codebase includes the main entry point (\main.rs\) which handles instructions and the game loop, a \Game\ struct (\game.rs\) managing state such as the player's wallet, betting logic, and win/loss conditions, and utility functions (\util.rs\) for input validation, random landmine generation, and user prompts. Users can now play this specific 3D grid navigation game with wagering mechanics.
_30\Cube/rust · high confidence
Initial release of the Kinema physics guessing game
Added a new Rust implementation of the 'Kinema' game, a physics-based guessing challenge where players estimate a ball's maximum height, time of flight, and velocity after a given time. This version corrects mathematical imprecisions found in the original BASIC source (such as using 9.81 m/s² for gravity instead of 10) and uses floating-point inputs/outputs for better accuracy, while retaining the original game logic and structure.
_52\Kinema/rust · high confidence
Initial release of the Mugwump text-based game
This change introduces the complete source code for the Mugwump game, a classic text-based puzzle where players attempt to find four hidden 'Mugwumps' on a 10x10 grid within 10 tries. The implementation includes the main entry point (\main.rs\) which handles the game loop and user prompts, a \Game\ struct (\game.rs\) that manages game state, random placement of targets, and distance calculation logic, a \Coordinate\ model (\coordinate.rs\) to track grid positions and states, and a \draw\ module (\draw.rs\) for rendering the board using Unicode box-drawing characters. A utility module (\util.rs\) provides standard input handling for coordinates and yes/no prompts.
_62\Mugwump/rust · high confidence
Initial release of the Super Star Trek game in Rust
This commit introduces the first working implementation of the Super Star Trek text-based game in Rust. It establishes the core game loop, model, and command structure, allowing players to navigate the galaxy, perform short and long-range scans, manage shields and energy, engage Klingons with phasers and photon torpedoes, and repair damaged systems. The game features an 8x8 quadrant grid with an 8x8 sector grid, random galaxy generation, and win/loss conditions based on destroying Klingons or surviving until the final stardate.
_04\_Awari/rust, 84\_Super\_Star\Trek/rust · high confidence
Introduce Games.Common library for shared C\# and VB.NET utilities
A new shared library, Games.Common, has been added to provide reusable components for game ports, including standardized text input/output handling via TextIO and ConsoleIO, as well as random number generation through IRandom and RandomNumberGenerator. The library is structured as a .NET solution with a main project and a test project, configured with nullable reference types and C\# 10.0 language features, and is designed to be referenced by other game projects to ensure consistent I/O and RNG behavior across the codebase.
_00\Common/dotnet · high confidence
Introduce Java implementation of the Blackjack game
Added a new Java-based terminal game for Blackjack in the \10\_Blackjack/java\ directory. The implementation includes core classes (\Blackjack\, \Game\, \Deck\, \Player\, \UserIo\, \ScoringUtils\) that support standard gameplay features such as betting, hitting, staying, doubling down, splitting hands, and collecting insurance. The code is structured to allow for testability by abstracting I/O and shuffling logic, mimicking the behavior of the original BASIC version while providing a modern, maintainable Java codebase.
_10\Blackjack/java · high confidence
Introduce abstraction for random number generation
The Games.Common.Randomness namespace now provides a new IRandom interface and a default RandomNumberGenerator implementation, allowing code to depend on an abstraction rather than the system's built-in Random class. This includes extension methods on IRandom to generate random floats and integers within specific ranges, as well as the ability to retrieve the previously generated value and reseed the generator.
_00\Common/dotnet/Games.Common/Randomness · high confidence
Introduce common text-based input/output library
The Games.Common.IO namespace now provides a unified interface for game input and output, featuring an IReadWrite contract with methods for reading characters, numbers, and strings, as well as writing formatted text. This includes a ConsoleIO implementation for standard input/output, a TextIO base class that replicates vintage BASIC-style input behavior (such as multi-line prompting and token validation), and supporting components like TokenReader, Tokenizer, and a Number struct for consistent number formatting.
_00\Common/dotnet/Games.Common/IO · high confidence
Introduced VB.NET 'Guess the Animal' game with decision-tree logic
Added a new interactive console application in the 03\_Animal/vbnet/Animal directory that implements the classic 'Guess the Animal' game. The game uses a binary decision tree (Branch class) to ask yes/no questions and guess the user's animal, allowing users to teach the computer new animals by providing distinguishing questions. The implementation includes a Game class for core logic, a ConsoleAdapter for input/output abstraction, and various extension methods for string and collection handling.
_03\Animal/vbnet/Animal · high confidence
Java implementation of the Animal guessing game with tree-based data structure
This location introduces a Java port of the classic 'Guess the Animal' game, converting the original logic from BASIC. The implementation replaces the previous list-based data structure with a tree structure for managing questions and answers, and includes a bonus 'TREE' command that allows users to visualize the decision data as a text-based tree. The entry also includes a Kotlin-based test suite that validates the interactive conversation flow, including scenarios for guessing correctly and teaching the game new animals.
_03\Animal/java · high confidence
Java port of classic Creative Computing games
This release adds Java implementations of several classic Creative Computing programs, including Acey Ducey, Blackjack, Buzzword Generator, Civil War, and Conway's Game of Life. The Acey Ducey game fixes a cheating loophole from the original BASIC version by preventing negative bets and ensures the player's balance is only displayed when it changes. The Blackjack implementation introduces an immutable Card record with proper suit handling and grammatically correct prose output (e.g., "AN ACE"). The Buzzword Generator provides a command-line interface for generating random educational buzzwords. The Civil War simulation allows users to play through historical battles with configurable strategies and battle descriptions. The Game of Life implementation supports pattern input, generation tracking, and an optional command-line flag (-s) to pause after each generation for user confirmation.
repository · high confidence
JavaScript port of Acey Ducey card game with browser and Node.js support
This change introduces a JavaScript implementation of the classic Acey Ducey card game, available for both browser and Node.js environments. The game logic allows players to bet on whether a third card's value will fall between two dealt cards, with betting validation ensuring wagers do not exceed available funds. A specific behavioral fix ensures that entering '0' as a bet correctly skips drawing the third card and starts a new hand, rather than treating it as an invalid input. The browser version renders output to a dedicated HTML page with terminal-style styling and handles user input via a DOM input element.
_01\_Acey\Ducey/javascript · high confidence
Kotlin implementation of the Animal guessing game
A Kotlin port of the classic 'Guess the Animal' game has been added to the 03\_Animal module. This implementation converts the original Vintage Basic source into a Kotlin application that uses a binary tree structure to guess animals based on user input. The entry includes the main application logic in \src/Animal.kt\ and full behavioral tests in \test/AnimalKtTest.kt\ that verify both standard guessing scenarios and the ability to learn new animals.
_03\Animal/kotlin · high confidence
MiniScript port of Super Star Trek with integrated instructions
A new MiniScript port of the classic Super Star Trek game has been added to the alternate languages section. This implementation combines the game logic and the instruction manual into a single executable file, removing the need for a separate instructions program that existed in the original BASIC version due to memory constraints. The port includes a README with instructions for running the game via Command-Line MiniScript or Mini Micro.
_00\_Alternate\_Languages/84\_Super\_Star\Trek · high confidence
MiniScript port of the Word guessing game added
A new MiniScript implementation of the classic Word guessing game has been added to the alternate languages collection. This port includes the source code (word.ms) and a README with instructions for running the game via the MiniScript command-line tool or Mini Micro, allowing users to play the same word-guessing logic available in other supported languages.
_00\_Alternate\_Languages/96\Word · high confidence
MiniScript ports added for Horserace and Hurkle games
New MiniScript versions of the Horserace and Hurkle games have been added to the alternate languages collection. The Horserace port includes a track length adjustment (23 rows instead of the original 27) and screen-clearing logic for better modern display compatibility. The Hurkle port implements the classic grid-guessing game with directional hints. Both include README files with instructions for running via Command-Line MiniScript, Mini Micro, or the Try-It! page.
_00\_Alternate\_Languages/50\_Horserace, 00\_Alternate\_Languages/51\_Hurkle, 00\_Alternate\_Languages/55\_Life, 00\_Alternate\_Languages/56\_Life\_for\_Two, 00\_Alternate\_Languages/59\_Lunar\_LEM\Rocket · high confidence
New 'Amazing' maze game ports in Go, MiniScript, and Pascal
The 'Amazing' program (a maze generator originally from Creative Computing) is now available in three additional languages: Go, MiniScript, and Pascal. The Go implementation provides a command-line version using standard libraries. The MiniScript port includes a README with instructions for running via the MiniScript command-line tool or Mini Micro, and relies on the standard 'listUtil' library. The Pascal port is provided in two variants: a simple procedural version and an object-oriented version using Lazarus/Free Pascal units (AmazingApplication, Maze, Room), complete with project files (.lpi) and build configuration.
_00\_Alternate\_Languages/02\Amazing · high confidence
New .NET port utility scripts for validation and project generation
Added a new DotnetUtils utility that scans game ports for C\# and VB.NET, providing a menu-driven CLI to validate solution and project file presence/naming, check for missing code files, and automatically generate missing .sln and .csproj/.vbproj files. The tool also includes an .editorconfig to enforce consistent coding styles and naming conventions across .NET ports.
_00\Utilities/DotnetUtils · high confidence
New C\# port of Super Star Trek
A new C\# implementation of the classic Super Star Trek game has been added to the 84\_Super\_Star\_Trek directory. This port translates the original BASIC source into an object-oriented C\# application, featuring a modular architecture with distinct classes for game objects (Enterprise, Klingon, Starbase), space navigation (Galaxy, Quadrant, Coordinates), and command handling. The implementation includes a comprehensive README with game history, rules, and porting notes regarding specific bug fixes from the original code, along with resource files for all in-game text and ASCII art.
_84\_Super\_Star\Trek · high confidence
New C\# port of the Civil War simulation game
A new C\# implementation of the classic 1968 Civil War simulation has been added to the 27\_Civil\_War directory. This port translates the original BASIC logic into modern C\#, featuring object-oriented classes for Army and Battle states, structured input handling via ConsoleUtils, and a solution file for Visual Studio. It preserves the original gameplay mechanics, including the 14 historical battles, resource allocation, and morale calculations, while providing a clean, maintainable codebase for .NET users.
_27\_Civil\War · high confidence
New C\# port of the Craps game with unit tests
A new C\# implementation of the classic Craps game has been added to the 29\_Craps directory. This port includes a solution file (Craps.sln) and project structure for both the application and its test suite. The application logic is separated into a \CrapsGame\ class for game rules, a \Dice\ class for random number generation, and a \UserInterface\ class for console interaction. The \Dice\ class uses \System.Random\ to generate fair rolls between 1 and 6, correcting the biased distribution found in the original BASIC source code. A corresponding test project (\CrapsTester\) has been added to verify that the dice rolls are valid and statistically random.
_29\Craps · high confidence
New C\# port of the Digits guessing game
A new C\# implementation of the 'Digits' game has been added to the 34\_Digits directory. This port translates the original BASIC source into modern C\#, featuring a structured game loop where the computer attempts to guess the next digit in a user-provided sequence of 0s, 1s, and 2s. The implementation includes a \Guesser\ class that uses weighted matrices to predict the next number, along with embedded text resources for instructions and game feedback.
_34\Digits · high confidence
New C\# port of the Hammurabi game
A new C\# implementation of the classic Hammurabi resource-management game has been added to the 43\_Hammurabi directory. This port includes a complete solution structure (Hammurabi.sln, Hammurabi.csproj) and source files (Program.cs, Rules.cs, View.cs, Controller.cs, and supporting types like GameState and ActionResult). It replicates the original BASIC game's mechanics—buying/selling land, feeding people, planting crops, and handling random events like plagues and rat infestations—while providing a modern, structured C\# codebase with a README explaining the conversion.
_43\_Hammurabi, 75\Roulette · high confidence
New C\#, Java, and JavaScript ports of the Mastermind game
This change introduces new implementations of the classic Mastermind logic game in C\#, Java, and JavaScript, alongside a comprehensive README explaining the computer's deduction algorithm. The C\# port features a structured object-oriented design with separate classes for game logic, input handling, and UI, while the Java port includes a memory-safe ceiling check on code positions to prevent out-of-memory errors during the computer's turn. The JavaScript port provides a browser-based version using a terminal-style CSS layout, and all ports faithfully reproduce the original BASIC game's mechanics, including the human-vs-computer and computer-vs-human modes.
_60\Mastermind · high confidence
New HTML-based terminal emulator for browser games
Adds a new \WebTerminal\ component that renders interactive terminal-based games directly in the browser using HTML, CSS, and JavaScript. This replaces or supplements the previous Node.js-only execution model by providing a client-side terminal emulator (\HtmlTerminal.js\) with a styled UI (\HtmlTerminal.css\), a demo page (\terminal.html\) that loads game scripts via URL hashes, and a common utility module (\common.mjs\) for standard input/output operations. The implementation includes mobile support, sticky headers with source links, and specific styling for prompts and cursors.
_00\Common/javascript · high confidence
New MiniScript and Go ports for Fur Trader and Football games
Added MiniScript and Go language ports for the Fur Trader and Football games, including source code and README instructions for running them via Command-Line MiniScript or Mini Micro.
_00\_Alternate\_Languages/38\_Fur\Trader · high confidence
New MiniScript and Pascal ports of the Blackjack game
Added new language ports for the Blackjack game, including a MiniScript implementation (blackjack.ms) with a dedicated README explaining command-line and Mini Micro usage, and a Pascal port with its own README. These additions expand the available ways to play the game beyond the primary set of supported languages.
_00\_Alternate\_Languages/10\Blackjack · high confidence
New MiniScript port of the Roulette game
A new version of the Roulette game has been added in MiniScript, located in the 00\_Alternate\_Languages/75\_Roulette/MiniScript directory. This port includes the full game logic (roulette.ms) and a README with instructions for running the game via Command-Line MiniScript or Mini Micro. The implementation preserves the original game's betting rules, payout structures, and interactive text-based interface.
_00\_Alternate\_Languages/75\Roulette · high confidence
New MiniScript, Bash, and Nim ports for Rock, Scissors, Paper
Users can now play the classic Rock, Scissors, Paper game using MiniScript, Bash, or Nim. The MiniScript port includes a README with instructions for running via the command-line interpreter or Mini Micro, as well as a web-based Try-It page. The Bash and Nim implementations replicate the original BASIC game logic, allowing players to choose the number of games (up to 10) and compete against the computer, with final scores displayed at the end.
_00\_Alternate\_Languages/74\_Rock\_Scissors\Paper · high confidence
New Python implementations for classic text games
This update adds Python ports for several classic games from the 'Basic Computer Games' collection, including Acey Ducey, Amazing, Blackjack, Boxing, Bug, Bullseye, Checkers, Civil War, Even Wins, Golf, and Hexapawn. These new entries provide users with modern, type-annotated Python versions of these legacy titles, expanding the available game library in the Python directory.
python · high confidence
New Ruby implementations of classic games and utilities
This update adds several new Ruby programs to the repository, including a maze generator (Amazing), a guess-the-animal game (Animal), a Blackjack model with insurance and splitting support, a Checkers game with modern object-oriented structure, and a FlipFlop puzzle game. These additions provide new interactive experiences and demonstrate various Ruby coding patterns, such as 1-based array simulation and state management.
ruby · high confidence
New Tic-Tac-Toe port collection added
Added a new collection of Tic-Tac-Toe game implementations across multiple languages, including C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET. Each port includes source code and a README noting the original source from Vintage Basic. The collection features two main game variants: a simple version where the computer goes first and plays a fixed sequence, and a more interactive version where the player chooses their symbol (X or O) and the computer uses basic strategy to block or win.
_89\Tic-Tac-Toe · high confidence
New alternate-language ports for Sine Wave and War
Added educational ports of the Sine Wave program to C++17, MiniScript, and Pascal, and of the War card game to MiniScript and D. These files provide the source code and README instructions for running the programs in these specific languages, expanding the available implementations beyond the core set.
_00\_Alternate\_Languages/78\_Sine\Wave · high confidence
New alternate-language ports for the Buzzword Generator
The Buzzword Generator (20\_Buzzword) is now available in three additional languages: Go, Nim, and MiniScript. These ports replicate the original Basic program's functionality—generating random 'educator-speak' phrases—allowing users to run the game via command-line Go or Nim executables, or interactively within the MiniScript environment (Try-It page, command-line, or Mini Micro).
_00\_Alternate\_Languages/20\Buzzword · high confidence
New language ports for the Slots game
Added new implementations of the classic Slots game in C\# (using dotnet-script), JavaScript (with a terminal-style HTML interface), Kotlin, Lua, and Visual Basic .NET. The C\# port includes a solution file and script, while the JavaScript version provides a browser-playable HTML page. Existing ports in Python, Perl, and Ruby are also present, with the Perl version notably fixing a known bug where non-adjacent matching symbols (e.g., Lemon-Cherry-Lemon) are now correctly treated as a double win.
(repo-wide) · high confidence
New language ports for the Stars guessing game
The 82\_Stars directory now includes implementations of the classic 'Stars' number-guessing game in C\#, JavaScript, Perl, Python, Ruby, Rust, and Visual Basic .NET, alongside the original BASIC source. Each port provides the same core gameplay—guessing a number between 1 and 100 with up to 7 attempts, receiving star-based feedback on proximity—adapted to its respective language's ecosystem, including specific UI handling for JavaScript (terminal-style HTML) and dependency management for Rust (rand crate) and C\# (common IO/randomness libraries).
_82\Stars · high confidence
New maintenance utilities and documentation for the 00\_Utilities folder
This change introduces a suite of helper tools and documentation to support the project's multi-language game ports. A new README explains the folder's purpose, while a generated TODO.md table tracks implementation status across C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and VB.NET. Several scripts are added: a Python script (markdown\_todo.py) to generate the TODO list, a Perl script (yatol.pl) to analyze file sizes and port progress, and Node.js utilities (build-index.js, find-missing-implementations.js, find-unimplemented.js) to auto-generate the main index.html and identify missing language implementations. Additionally, a Notepad++ syntax highlighting file (VintageBASIC.xml) and a BASIC-to-Perl converter (bas2perl.pl) are included to aid development and maintenance.
_00\Utilities · high confidence
New ports of Conway's Game of Life added for C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and VB.NET
This change introduces a collection of new language-specific implementations of the classic 'Life' cellular automaton (originally from Basic Computer Games) across the 55\_Life directory. Each port (C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and VB.NET) includes its own source code and README, replicating the original BASIC behavior such as centered pattern input, the '.' prefix for leading spaces, and 'INVALID!' warnings when patterns drift off-screen. Notable behavioral details preserved or adapted include the C\# and Python support for the '.' input hack, the Java option to halt between generations with -s, and the Rust port's addition of a half-second pause between generations and rejection of inputs exceeding 66 columns.
(repo-wide) · high confidence
New ports of the War card game added for C\#, D, Java, JavaScript, Kotlin, Perl, Python, Ruby, and Rust
This update adds complete implementations of the classic 'War' card game (originally from Basic Computer Games, 1978) in nine new languages: C\#, D, Java, JavaScript, Kotlin, Perl, Python, Ruby, and Rust. Each port includes the core game logic—shuffling a 52-card deck, dealing pairs, comparing ranks, and tracking scores—as well as user interface components for displaying cards (using suit symbols or ASCII codes), prompting for directions, and handling yes/no input. The C\# port additionally includes a unit test suite for card comparison and deck shuffling, while the Perl port supports a --unicode flag for displaying suit glyphs. These files provide the specific language-specific source code, build configurations (e.g., C\# solution/project files), and README documentation for running each port.
_94\War · high confidence
Port 'Change' to C\#, JavaScript, Perl, Python, Rust, and VB.NET
The classic 'Change' program (originally from Basic Computer Games, 1978) is now available in six additional languages: C\#, JavaScript, Perl, Python, Rust, and Visual Basic .NET. Each port implements the same core functionality: the user enters the cost of an item and the amount paid, and the program calculates and displays the correct change in bills and coins (up to $100). The JavaScript version includes a browser-based HTML interface, while the other ports are command-line applications. Source code and READMEs for each language are provided in their respective subdirectories.
_22\Change · high confidence
Port Buzzword to C\#, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and VB.NET
The Buzzword generator, originally from Basic Computer Games (1978), is now available in multiple languages including C\#, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET. Each port implements the core functionality of generating random three-word phrases from a predefined list of educational buzzwords, allowing users to request new phrases or quit. The ports include necessary project files (such as .sln and .csproj for C\# and VB.NET) and README files with porting notes and source attribution.
_20\Buzzword · high confidence
Port Nicomachus puzzle to C\#, JavaScript, Kotlin, Lua, Perl, Python, and VB.NET
The Nicomachus arithmetic puzzle (also known as the Boomerang puzzle) is now available in seven additional languages: C\#, JavaScript, Kotlin, Lua, Perl, Python, and Visual Basic .NET. Each port includes the source code and a README noting the original source from Vintage Basic, allowing users to run the classic number-guessing game in their preferred environment.
_64\Nicomachus · high confidence
Port Rock, Scissors, Paper to C\#, JavaScript, Lua, Perl, Ruby, and Rust
The classic 1978 'Rock, Scissors, Paper' game from Basic Computer Games is now available in C\#, JavaScript, Lua, Perl, Ruby, and Rust, in addition to existing Java, Python, and Visual Basic .NET ports. Each implementation preserves the original terminal-based interaction, allowing users to play up to ten games against the computer with standard win/loss/tie logic and final score reporting.
_74\_Rock\_Scissors\Paper · high confidence
Port of 'Animal' guessing game to Perl
Added a Perl implementation of the classic 'Guess the Animal' interactive game. Users can now play the game using a Perl script that utilizes a tree-based database to learn new animals through user interaction, replacing the original Vintage Basic source.
_03\Animal/perl · high confidence
Port of 'Animal' interactive guessing game to Python
This change introduces a new Python implementation of the classic 'Animal' game (originally from Vintage Basic), allowing users to play an interactive guessing game where the computer learns new animals through user input. The entry includes the main game logic in \animal.py\, which uses a binary tree structure to store questions and animals, and a \README.md\ documenting the source and conversion.
_03\Animal/python · high confidence
Port of 'Life for Two' game to C\#, Java, JavaScript, Kotlin, Perl, Python, Ruby, and VB.NET
This change introduces new implementations of the 'Life for Two' game (originally from Basic Computer Games, 1978) across multiple languages. The C\# implementation in \csharp/\ provides a structured object-oriented design with separate classes for \Board\, \Coordinates\, \Piece\, \Generation\, and \Game\, handling the 5x5 grid logic, neighbor counting, and player turn management. The Java, JavaScript, Perl, Python, Ruby, and VB.NET ports in their respective directories (\java/\, \javascript/\, \perl/\, \python/\, \ruby/\, \vbnet/\) translate the original BASIC logic into their native syntax. The Perl version notably includes an optional fix for a bug in the original BASIC code regarding simultaneous coordinate entry and supports input hiding via the \Term::ReadKey\ module. The JavaScript version provides an HTML/JS interface for browser play. All ports maintain the core gameplay: two players placing pieces on a 5x5 board, with cells evolving based on neighbor counts, aiming to eliminate the opponent's pieces.
_56\_Life\_for\Two · high confidence
Port of 'Number' game to multiple new languages
The classic 'Number' guessing game from Basic Computer Games (1978) is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET. This port adds new playable implementations for users who prefer these specific languages, alongside the existing original BASIC source. The JavaScript version includes a browser-based HTML interface, while the C\# and VB.NET versions provide Visual Studio solution files for easy building.
_66\Number · high confidence
Port of 15\_Boxing to C\#, Java, JavaScript, Perl, and VB.NET
The 15\_Boxing game, originally from Basic Computer Games (1978), is now available in five new languages. The C\# implementation refactors the original logic into an object-oriented structure using strategy patterns for player and opponent attacks. The Java port provides a direct translation with a helper class for BASIC-like random number generation. The JavaScript version runs in the browser via an HTML file, while the Perl and VB.NET ports offer native console experiences. Each language folder includes a README noting the source and target technology.
_15\_Boxing, 31\_Depth\Charge · high confidence
Port of Bullfight game to C\#, Java, JavaScript, Python, Kotlin, Lua, and Perl
The classic 1978 'Bullfight' text game is now available in multiple modern languages. This location adds the C\# implementation (using a coroutine-based event loop with a Mediator pattern), the Java implementation, the JavaScript browser version (with an HTML file), the Python implementation, and README files for Kotlin, Lua, and Perl ports. The original BASIC source code and a descriptive README with porting notes are also included. The C\# version refactors the original logic into distinct Action, ActionResult, and Event types, while the Java and Python versions maintain the original procedural flow.
_17\_Bullfight, 83\_Stock\Market · high confidence
Port of Even Wins game to multiple languages
This change adds new implementations of the 'Even Wins' game (originally from Basic Computer Games, 1978) in C\#, Java, JavaScript, Perl, Python, Ruby, Kotlin, Lua, and Visual Basic .NET. The port includes two versions of the game: a deterministic version where the computer plays by fixed rules, and a learning version where the computer gradually improves its strategy. Each language implementation includes its own README file documenting the conversion source and target language, along with solution/project files for C\# and VB.NET.
(repo-wide) · high confidence
Port of H-I-Q logic puzzle to multiple languages
This change adds a new port of the classic 'H-I-Q' peg-solitaire logic puzzle (originally from Basic Computer Games, 1978) to several new programming languages. The diff introduces complete implementations and project files for C\# (Visual Studio solution), D (with a simplified board coordinate system and improved UI), Java, JavaScript (with a terminal-style HTML interface), Kotlin, Lua, Perl, Python (with type annotations), and Visual Basic .NET. Each language directory includes a README crediting the original source and the specific port author, along with the necessary source code to run the game.
_48\_High\IQ · high confidence
Port of One Check game to C\#, Java, JavaScript, Perl, Python, and VB.NET
The One Check solitaire checker puzzle is now available in multiple programming languages. This update adds new implementations in C\#, Java, JavaScript (with an HTML interface), Perl, Python, and Visual Basic .NET, alongside the original BASIC source. Each port faithfully recreates the classic gameplay where players remove checkers via diagonal jumps on a 64-square board, including the original instructions, board visualization, move validation, and game summary features.
_67\_One\Check · high confidence
Port of Poetry game to C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and VB.NET
The Poetry game, originally published in Basic Computer Games (1978), is now available in multiple languages including C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Visual Basic .NET. Each port faithfully reproduces the original behavior: generating random verse in a Haiku-like style using four groups of phrases, with random insertion of commas (19% probability), indentation (22% probability), and new paragraphs (18% probability, at least once every 20 phrases). The C\# implementation uses a Context class to manage state and Phrase objects for text generation, while other ports follow similar logic adapted to their respective languages. A README in each directory provides conversion notes and source attribution.
(repo-wide) · high confidence
Port of Splat to C\#, JavaScript, Perl, Python, and other languages
The 81\_Splat directory now includes new implementations of the classic 'Splat' parachute-jump simulation in C\#, JavaScript, Perl, Python, Ruby, Kotlin, and Lua, alongside the original BASIC source. Users can now run the game in their preferred environment, with the JavaScript version providing a browser-based interface via splat.html and the other ports offering standard command-line or script execution.
_81\Splat · high confidence
Port of Traditional Nim game to multiple languages
The Traditional Nim game is now available in Python, JavaScript, Ruby, C\#, Visual Basic .NET, Java, Kotlin, Lua, and Perl. The Python implementation offers a structured class-based experience with a fixed 7-5-3-1 pile setup, while the JavaScript version provides a browser-based interface using a terminal-style stylesheet. The other language ports are direct conversions of the original BASIC source, preserving the classic gameplay mechanics and allowing users to choose their preferred environment to play.
_65\Nim · high confidence
Port of Vintage Basic 'Weekday' program to MiniScript
Added a MiniScript port of the 'Weekday' demonstration program (originally from Vintage Basic) to the 00\_Alternate\_Languages/95\_Weekday folder. The program calculates the day of the week for a given date, determines the age in years, months, and days between two dates, and estimates time spent sleeping, eating, and working based on standard averages. It also includes a warning for Friday the 13th and a retirement year estimate. A README file provides instructions for running the program via Command-Line MiniScript or Mini Micro.
_00\_Alternate\_Languages/95\Weekday · high confidence
Port of Vintage Basic Basketball to C\#
This change introduces a playable C\# implementation of the classic Dartmouth College basketball game, originally sourced from Vintage Basic. The application allows users to manage a game between Dartmouth and a chosen opponent, featuring a full game loop with center jumps, offensive play resolution, and defensive strategy selection. Key features include a clock system that handles half-time and overtime periods, a scoreboard that tracks points and manages possession, and probabilistic play outcomes influenced by the selected defense. The codebase is structured with distinct classes for game logic, shot types, and team management, utilizing embedded resources for game text and prompts.
_07\Basketball/csharp · high confidence
Port of the 'Bug' game to C\#
A new C\# implementation of the classic 'Bug' game has been added to the 16\_Bug directory. This port translates the original BASIC logic into modern C\#, featuring a structured object-oriented design with distinct classes for game parts (Body, Neck, Head, etc.) and a dedicated Game loop. The implementation includes embedded text resources for instructions and messages, and it is wired up via a simple Program entry point using console I/O and random number generation.
_16\_Bug, 72\Queen · high confidence
Port of the 'Bunny' ASCII art game to multiple languages
Adds a new port of the 'Bunny' game (originally from Basic Computer Games, 1978) to the 19\_Bunny location. This includes a faithful BASIC implementation, a C\# port using a .NET solution, a JavaScript version with an HTML shell, and ports to Python, Ruby (both faithful and modern styles), Perl, Java, Kotlin, and Lua. Each language directory contains the source code and a README noting the conversion source.
_19\Bunny · high confidence
Port of the 'Queen' text-based game to Rust
The 'Queen' game, originally a Creative Computing title, has been implemented in Rust. This port introduces a complete text-based experience where players and the computer alternate moving a Queen piece on an 8x8 grid, aiming to reach the bottom-left corner. The Rust implementation includes a new AI module that selects moves based on preferred and safe squares, a game loop handling turn management and board rendering with Unicode box-drawing characters, and utility functions for input validation and legal move checking.
_72\Queen/rust · high confidence
Port of the Awari board game to Python
Added a new Python implementation of the classic African board game Awari (also known as Kalah or Mancala). The game features a two-player interface (human vs. computer) with a 2-ply lookahead AI that utilizes a 'losing book' mechanism to penalize moves leading to previously recorded losses. The entry includes the main game logic in \awari.py\ and a \README.md\ documenting the source and porting details.
_04\Awari/python · high confidence
Port of the Guess game to C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and VB.NET
The 41\_Guess directory now includes implementations of the classic number-guessing game in ten new languages: C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET. Each port replicates the original BASIC logic where the computer selects a random number within a user-defined limit and provides 'Too high' or 'Too low' feedback until the user guesses correctly, while also reporting whether the user met the optimal binary-search guess count. The C\# implementation uses dependency injection for I/O and randomness, while the JavaScript version provides a browser-based interface via an HTML file.
(repo-wide) · high confidence
Port of the SPLAT parachute jump simulation to Java
Added a new Java implementation of the SPLAT game, a simulation where players attempt to open their parachute at the last possible moment. The application allows users to select their own terminal velocity and gravitational acceleration or let the computer choose random values from various celestial bodies. It tracks past successful jumps to provide comparative feedback on performance and includes input validation for numeric entries.
_81\Splat/java · high confidence
Port of the classic Bagels guessing game to Python
Added a Python implementation of the 'Bagels' number-guessing game, originally from BASIC Computer Games (1978). The new \bagels.py\ script allows users to guess a randomly generated three-digit number with unique digits, receiving clues such as 'FERMI' for correct digits in the correct position, 'PICO' for correct digits in the wrong position, and 'BAGELS' for no correct digits. The game supports up to 20 guesses and includes input validation to ensure guesses are three unique numeric characters.
_05\Bagels/python · high confidence
Ported 12\_Bombs\_Away game to Rust
The 12\_Bombs\_Away game has been implemented in Rust, providing a new language option for players. The code introduces a text-based interface where users select a side (Italy, Allies, Japan, or Germany) and target, with specific prompts and messages for each choice. The game logic includes mission counting, random number generation for success/failure outcomes, and kamikaze mission handling for the Japan side.
_05\_Bagels/lua, 12\_Bombs\Away/rust · high confidence
Ported the Battle game logic to Rust
The 09\_Battle module has been implemented in Rust, introducing the core game mechanics for a Battleship-style application. This includes ship placement logic for Destroyers, Cruisers, and Aircraft Carriers on a 6x6 grid, coordinate handling for user input, and the reporting of hits, misses, and already-targeted cells.
_09\Battle/rust · high confidence
Ported vintage BASIC games from Basic Computer Games (1978)
Added source code and documentation for four classic games—Animal, Awari, Bagels, and Bounce—ported from the 1978 Basic Computer Games collection. Each game is provided as a standalone BASIC program (\.bas\) with a corresponding \README.md\ that includes rules, historical context, and a section for porting notes. These additions allow users to run and interact with these retro titles directly.
(repo-wide) · high confidence
Porting Lunar LEM Rocket to multiple languages
The Lunar LEM Rocket game is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, in addition to the original BASIC versions. These ports allow users to play the classic lunar landing simulation in their preferred modern language environment.
_59\_Lunar\_LEM\Rocket · high confidence
Porting Synonym game to multiple new languages
The Synonym vocabulary drill game (originally from Basic Computer Games, 1978) is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET. Each port implements the original gameplay where the computer presents a word and the user must type a synonym, with a 'HELP' command that reveals and discards a synonym from the list. The JavaScript version includes a browser-based HTML interface using a terminal-style stylesheet, while the other ports provide standard command-line implementations.
_45\_Hello, 85\Synonym · high confidence
Porting the TRAP game to multiple languages
The TRAP guessing game, originally from Basic Computer Games (1978), is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET. Each port includes a README noting the conversion source and a solution file for the .NET implementations, allowing users to play the game in their preferred language.
_28\_Combat, 92\Trap · high confidence
Porting the Tower of Hanoi game to C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, and Ruby
The 90\_Tower location now includes complete implementations of the classic Towers of Hanoi puzzle in eight additional languages: C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, and Ruby. Each port faithfully recreates the original 1978 BASIC game's logic, including the ASCII tower display, disk movement rules, and specific error messages, while adding language-specific project structures and README files documenting the conversion source.
_90\Tower · high confidence
Repository initialization with project structure and documentation
The repository has been initialized with the core project structure, including a comprehensive README outlining the goal of porting the classic BASIC Computer Games to modern, memory-safe languages (C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, VB.NET). A new HOW\_TO\_RUN\_THE\_GAMES.md file provides specific instructions for executing the games in each supported language. An index.html file serves as a central navigation hub for the JavaScript browser-based versions. Additionally, development tooling has been added, including a .pre-commit-config.yaml for code quality checks (black, isort, etc.), a .coveragerc to exclude test files from coverage reports, and a .nojekyll file to ensure GitHub Pages renders the content correctly.
(repo-wide) · high confidence
Ruby port of the Acey Ducey card game
Added a Ruby implementation of the classic Acey Ducey card game, originally from BASIC Computer Games (1978). The game allows players to bet on whether a third card's value will fall between two dealt cards, starting with $100 in virtual currency. This entry covers the Ruby source code and its accompanying README.
_01\_Acey\_Ducey/lua, 01\_Acey\Ducey/ruby · high confidence
Rust implementation of the Acey Ducey card game
A new Rust-based version of the Acey Ducey card game has been added. Users can now play the classic game where they bet on whether a third card's value falls between two dealt cards. The implementation includes a 100-dollar starting bank, input validation for bets, and a restart option if the user loses all their money.
_01\_Acey\Ducey/rust · high confidence
Rust port of the Amazing maze generator
A new Rust implementation of the 'Amazing' maze generator has been added to the 02\_Amazing/rust directory. The application prompts users for width and height, generates a random maze using a depth-first search algorithm with backtracking, and displays the result in the console. It includes input validation to ensure dimensions are greater than 1 and waits for user input before exiting.
_02\Amazing/rust · high confidence
Rust port of the Horserace game
A new Rust implementation of the Horserace game has been added to the 50\_Horserace/rust directory. This port replicates the original interactive betting experience, allowing up to ten players to enter names, place bets on horse odds, and watch a text-based race unfold with real-time position updates. The code includes modules for game logic, horse management (including randomizing odds and advancing positions), player state handling, and input utilities.
(repo-wide) · high confidence
Behavioural changes
1 commit (0 fixes) modifying 00\_Common/rust/crates/basic\_input
A change to existing behaviour in 00\_Common/rust/crates/basic\_input — 1 commit, 5 files: “A Rust crate to handle the eccentricities of BASIC input statements”.
_00\_Common/rust/crates/basic\input · medium confidence · unverified
1 commit (0 fixes) modifying 07\_Basketball/rust
A change to existing behaviour in 07\_Basketball/rust — 1 commit, 1 file: “feat: added rust implementation of Basketball”.
_07\_Basketball/rust, 14\Bowling/rust · medium confidence · unverified
1 commit (0 fixes) modifying 40\_Gomoko/rust
A change to existing behaviour in 40\_Gomoko/rust — 1 commit, 1 file: “Add Rust port of 40\_Gomoku”.
_40\Gomoko/rust · medium confidence · unverified
C\# port of 30\_Cube adds deterministic mode via command-line switch
The C\# implementation of the 30\_Cube game now supports a \--non-random\ command-line switch. This allows users to run the game with deterministic mine locations (using a \ZerosGenerator\) instead of the default randomized behavior, addressing a quirk in the original BASIC source where the randomization logic was biased or non-functional depending on internal state.
_30\Cube · high confidence
Mastermind game logic refactored into a library with improved error handling
The Mastermind application has been restructured to separate game logic from the entry point. The core game mechanics, including code generation, guess evaluation, and round management, are now encapsulated in a new \lib.rs\ module, exposing a \Config\ struct for setup and a \run\ function for execution. The \main.rs\ entry point now handles initialization and error propagation using Rust's \Result\ types and \std::process::exit\ for failures, replacing the previous panic-on-error approach. This change improves the robustness of the application by providing clearer error messages for invalid configuration inputs and runtime issues.
_60\_Mastermind/rust/Mastermind\_refactored\_for\conventions · high confidence
Ported Batnum game to Rust
The Batnum game implementation has been ported to Rust. This change introduces a new Rust source file containing the complete game logic, including user input handling, parameter configuration (pile size, min/max selection, start/win options), and the core gameplay loop for both player and computer moves.
_08\Batnum/rust · high confidence
Refactor play resolution into dedicated team-specific classes
The logic for resolving basketball plays has been restructured into specific classes: HomeTeamPlay and VisitingTeamPlay handle the distinct probabilistic outcomes and game flow for each side, while a new BallContest class manages shot-blocking scenarios. This change encapsulates the resolution helpers and simplifies the continuation logic, ensuring that the home and visiting teams' actions are processed through their own dedicated implementations.
_07\Basketball/csharp/Plays · high confidence
Test coverage
Added BASIC test scripts for input, output, and random number generation; Added ConsoleTest helper for testing console interactions; Added unit tests for TextIO, Token, and Tokenizer components; Added unit tests for the Animal guessing game logic; Expose internals to unit tests.
Dependencies
Add Elm and Rust ports for several games and update .NET project configurations
This change introduces new language implementations for several games, including Elm ports for Acey Ducey and Awari, and Rust ports for Acey Ducey, Amazing, Awari, Bagels, Battle, Blackjack, Bombardment, Bombs Away, Bullseye, and Buzzword. It also updates the .NET project files across the solution, standardizing many C\# and VB.NET projects to target .NET 6.0 and enabling nullable reference types and implicit usings, while the common library and test projects are configured for .NET 6.0 with updated test SDKs.
(dependencies) · high confidence
Add Python CI linting and type-checking dependencies
The Python utilities directory now includes a dedicated CI requirements file (ci-requirements.in) and its compiled lockfile (ci-requirements.txt). This introduces flake8 with plugins (bugbear, comprehensions, implicit-str-concat) for code quality checks and mypy for static type checking, establishing the tooling foundation for the Python codebase's continuous integration pipeline.
_00\Utilities/python · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 41 → 38 (-3.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 38 → 33 (-4.6)
- Architecture 96 → 73 (-23.3)
- Maturity 46 → 56 (+9.6)
- Readiness 37 → 37 (+0.0)
- Security 36 → 32 (-3.7)
- Performance 100 → 100 (+0.0)
Resolved (117)
- Documentation: no project overview (20_Buzzword/README.md)
- Documentation: no project overview (21_Calendar/README.md)
- Dormant codebase
- Duplicated block (15 lines × 2) (27_Civil_War/python/Civilwar.py)
- Duplicated block (15 lines × 3) (27_Civil_War/python/Civilwar.py)
- Duplicated block (15 lines × 3) (49_Hockey/python/hockey.py)
- Duplicated block (16 lines × 2) (17_Bullfight/python/bullfight.py)
- Duplicated block (16–17 lines × 2) (49_Hockey/python/hockey.py)
- Duplicated block (17 lines × 2) (27_Civil_War/python/Civilwar.py)
- Duplicated block (17 lines × 2) (84_Super_Star_Trek/python/superstartrekins.py)
- Duplicated block (19 lines × 2) (84_Super_Star_Trek/python/superstartrekins.py)
- Duplicated block (23 lines × 2) (28_Combat/python/combat.py)
- Duplicated block (5 lines × 9) (08_Batnum/java/src/BatNum.java)
- Duplicated block (6 lines × 2) (16_Bug/java/src/ComputerBug.java)
- Duplicated block (6 lines × 2) (22_Change/java/src/Change.java)
- Duplicated block (6 lines × 2) (25_Chief/java/src/Chief.java)
- Duplicated block (6 lines × 2) (41_Guess/java/src/Guess.java)
- Duplicated block (6 lines × 2) (51_Hurkle/java/src/Hurkle.java)
- Duplicated block (6 lines × 3) (08_Batnum/java/src/BatNum.java)
- Duplicated block (6 lines × 3) (08_Batnum/java/src/BatNum.java)
- …and 97 more
New (390)
- BasketballGame::dartmouth_jump_shot (cognitive 16) (07_Basketball/rust/src/main.rs)
- BowlingGame::play_ball (cognitive 20) (14_Bowling/rust/src/main.rs)
- Concentrated knowledge decay
- Documentation: no build, run or usage example (01_Acey_Ducey/csharp/README.md)
- Documentation: no build, run or usage example (02_Amazing/csharp/README.md)
- Documentation: no build, run or usage example (03_Animal/csharp/README.md)
- Documentation: no build, run or usage example (04_Awari/csharp/README.md)
- Documentation: no build, run or usage example (05_Bagels/csharp/README.md)
- Documentation: no build, run or usage example (06_Banner/csharp/README.md)
- Documentation: no build, run or usage example (07_Basketball/csharp/README.md)
- Documentation: no build, run or usage example (08_Batnum/csharp/README.md)
- Documentation: no build, run or usage example (09_Battle/csharp/README.md)
- Documentation: no build, run or usage example (10_Blackjack/csharp/README.md)
- Documentation: no build, run or usage example (11_Bombardment/csharp/README.md)
- Documentation: no build, run or usage example (13_Bounce/csharp/README.md)
- Documentation: no build, run or usage example (14_Bowling/csharp/README.md)
- Documentation: no build, run or usage example (15_Boxing/csharp/README.md)
- Documentation: no build, run or usage example (16_Bug/csharp/README.md)
- Documentation: no build, run or usage example (17_Bullfight/csharp/README.md)
- Documentation: no build, run or usage example (18_Bullseye/csharp/README.md)
- …and 370 more
Changes since last survey
- 8 commits — 8 feature/other, 0 fixes
By area
- (repo) — 7 commits
- 00_Alternate_Languages/01_Acey_Ducey — 1 commit
Notable commits
- change: Merge pull request #949 from aconconi/71_poker_python_branch
- change: Merge pull request #950 from UncleScientist/rust_gomoku
- change: Merge pull request #952 from UncleScientist/rustlib
- change: Merge pull request #954 from astynax/84_Super_Star_Trek/rust/non-integer-torpedo-courses
- change: Merge pull request #955 from ainyava/feat-basketball-in-rust
- change: Merge pull request #956 from ainyava/feat-bowling-port-to-rust
- change: Merge pull request #958 from jonatasdemello/remove-exe-files
- change: remove binary files (shoud not be in the repo)
Architecture
- Unchanged — 103 containers · 6 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
coding-horror/basic-computer-games was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 12 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit a81c331c1d32f9553c6226639a415bfceb2daed6 — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.42+preprod-6bc2a431cb25.