coding-horror/basic-computer-games

This system is a comprehensive repository of classic text-based computer games, originally written in BASIC, now ported to a wide variety of modern programming languages including C\#, Java, Python, Rust, and JavaScript. It provides multiple implementations of each game, allowing users to play titles like Blackjack, Mastermind, and Game of Life in their preferred language. The project also includes shared utility libraries for input/output and randomness, as well as tooling for validation and documentation.

108 changes.

This period was defined by the extensive porting of classic BASIC games into a wide array of modern programming languages, including C\#, Java, JavaScript, Python, Rust, and others. The work focused on replicating original game logic and mechanics across these new implementations, often accompanied by documentation and build configurations to support each language's ecosystem.

83 changes.

This period was dominated by the extensive porting of classic BASIC games into a wide variety of modern and alternate programming languages, including Rust, Go, MiniScript, and C\#. Significant effort was also directed toward building shared utility libraries for .NET and JavaScript, as well as establishing CI tooling and test coverage to support this expanding codebase.

19 changes.

This period was defined by the addition of numerous new language implementations, with a heavy focus on porting classic BASIC games and exercises to Rust. The project also expanded its support for alternative scripting languages, introducing ports for MiniScript, Nim, D, and Swift alongside an Elixir game.

A new implementation of the Acey Ducey card game has been added to the Rust directory. The application allows users to play a betting card game where they predict if a third card's value falls between two dealt cards. The program manages a virtual bankroll, handles user input for bets, and provides feedback on wins or losses, with a loop to restart the game after bankruptcy.

_01\_Acey\Ducey/rust · high confidence

Introduces a new 'Change' program, originally from Basic Computer Games (1978), which calculates the correct change for items costing up to $100. Implementations are added for C\#, JavaScript, Perl, Python, Rust, and Visual Basic .NET, each accompanied by a README with porting notes or source attribution.

_22\Change · high confidence

The 'Hello' game, a conversational program originally published in Basic Computer Games (1978), is now available in multiple languages. This change adds the original BASIC source, a Python implementation with type annotations, and new ports in C\#, Java, JavaScript, Kotlin, Lua, Perl, and Ruby. Each language-specific directory includes the source code, a README noting the conversion, and, where applicable, project/solution files (e.g., .sln, .csproj, .vbproj) to support building the respective implementations.

_45\_Hello, 85\Synonym · high confidence

Adds the 'Love' game, a tribute to Robert Indiana's artwork, implemented in C\#, Java, JavaScript, Perl, Python, Ruby, Rust, and VB.NET, each with their own README and source files. The C\# implementation includes a solution file, pattern logic, and resource handling. The JavaScript version provides an HTML/JS interface. Each language folder contains the specific code and documentation for that port.

_58\Love · high confidence

The 'Name' game, originally published in Basic Computer Games (1978), is now available in multiple languages. Users can run the interactive program in C\#, Java, JavaScript, Lua, Perl, Python, Ruby, and Visual Basic .NET. Each port includes a README with source attribution and porting notes, and the core logic remains consistent: the program asks for a name, displays it reversed, then sorted alphabetically, and asks for user confirmation.

_63\Name · high confidence

The DotnetUtils utility now includes an .editorconfig file that enforces consistent C\# and VB.NET coding styles, including naming conventions (PascalCase for types/interfaces, camelCase for private members) and style suggestions (e.g., null propagation, collection initializers). Additionally, new C\# utility scripts and classes (Extensions, Functions, Methods, PortInfo, PortInfos) have been added to support .NET port management. These utilities provide methods for running external processes, parsing XML project files, and inspecting port structures (listing solution, project, and code files). The scripts enable validation checks, such as ensuring each port has at least one executable project, and can generate missing solution or project files.

_00\Utilities/DotnetUtils · high confidence

Users can now play the classic '23 Matches' game, which has been added as a new BASIC implementation (23matches.bas) and a new MiniScript port (23matches.ms), each accompanied by a README explaining how to run the game.

_00\_Alternate\_Languages/93\_23\Matches · high confidence

The 3D Plot game is now available in BASIC, C\#, D, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Visual Basic .NET. Each implementation renders a 3D surface plot using ASCII characters, with the D version including an additional 'bonus' mode that randomly selects and plots different mathematical functions.

_87\_3-D\Plot · high confidence

Introduces new implementations of the 3D Plot program in MiniScript and D, alongside their respective README files. The D version includes a bonus feature that allows the program to randomly select and plot different mathematical functions, demonstrating compile-time code generation capabilities.

_00\_Alternate\_Languages/87\_3-D\Plot · high confidence

A new JavaScript implementation of the classic Acey Ducey card game is now available. The addition includes the main game logic in aceyduey.js, a corresponding HTML file (aceyduey.html) that loads the script and applies terminal styling, and a Prettier configuration (.prettierrc.json) to standardize code formatting. Users can now play the game in a browser environment or via Node.js.

_01\_Acey\_Ducey/javascript, 01\_Acey\Ducey/perl · high confidence

Users can now play the classic board game Awari in two new alternate language implementations. A MiniScript port provides a command-line and Mini Micro playable version with a computer opponent, while an Elm port offers a browser-based interactive game with a graphical board and turn-based play. Both implementations include their own README files with setup and usage instructions.

_00\_Alternate\_Languages/04\Awari · high confidence

Added the BASIC source code (batnum.bas) and a README for the Batnum game, which allows players to remove objects from a pile in a strategy game based on modulo arithmetic. The game supports configurable rules for winning conditions and starting positions.

_08\Batnum · high confidence

Users can now play the classic 'Bagels' number-guessing game using a new Lua implementation. The game allows players to guess a secret number, receiving clues such as 'PICO' (correct digit, wrong position), 'FERMI' (correct digit, right position), or 'BAGELS' (no correct digits). The Lua version supports a configurable difficulty level (defaulting to a 3-digit code) and includes a scoring system that tracks successful guesses across multiple rounds.

(repo-wide) · medium confidence

Added the 'Bombardment' game, a turn-based strategy game where players place four platoons on a 5x5 grid and fire missiles to destroy the opponent's platoons. The change includes the BASIC source code (bombardment.bas) and a README.md containing game rules, historical context, and porting notes.

_11\Bombardment · high confidence

The Bombs Away game, a World War II bomber simulation originally from Basic Computer Games (1978), has been added to the collection. The entry includes the BASIC source code (bombsaway.bas) and a README.md file that provides game instructions, historical context, and a note about a known bug where playing as Japan on a non-first mission can make completion impossible due to a variable initialization error.

_12\_Bombs\Away · high confidence

The repository now includes new implementations of the classic 'Bowling' game across multiple languages. A faithful port of the original 1970s BASIC game is provided in C\#, Java, JavaScript, Perl, Python, and VB.NET, each accompanied by a README explaining the source and conversion details. The C\# and VB.NET versions include project and solution files for easy building. The Perl implementation offers an optional 'advanced' mode for improved scoring and display. The Python version introduces named players and fixes original scoring bugs.

_14\_Bowling, 44\_Hangman, 67\_One\Check · high confidence

The classic 1978 Olympic boxing game is now available in C\#, Java, JavaScript, Perl, Python, Ruby, and Visual Basic .NET, each providing a faithful recreation of the original BASIC title where players compete in a three-round match against a computer opponent. The C\# and Java implementations feature structured object-oriented designs with separate strategy classes for player and opponent attacks, while the Python version utilizes JSON configuration files to define punch behaviors and outcomes. The JavaScript version includes a terminal-style HTML interface, and all ports include README files documenting the original source and conversion details.

_15\_Boxing, 19\_Bunny, 38\_Fur\Trader · high confidence

The Buzzword generator, a program that creates random phrases from lists of educational and corporate buzzwords, has been added in multiple language implementations. The diff includes the original BASIC source, along with ports to C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, each accompanied by a README and, where applicable, a solution file or HTML wrapper.

_20\Buzzword · high confidence

Added new language ports for the Hello program in the Alternate Languages section. This includes a C implementation (hello.c) and a BASIC implementation (hello.bas), each providing an interactive console experience that asks for the user's name and engages in a humorous, multi-turn conversation about life advice and payment. A README.md was also added to explain the purpose of this folder for non-standard language ports.

_00\_Alternate\_Languages/45\Hello · high confidence

New C and MiniScript versions of the 30\_Cube game have been added to the alternate languages directory. The C implementation (cube.c) provides a command-line game where players navigate a 3x3x3 cube to reach the opposite corner while avoiding randomly placed mines. The MiniScript implementation (cube.ms) offers the same gameplay logic adapted for that language, accompanied by a README (README.md) with instructions for running the game via command line or Mini Micro.

_00\_Alternate\_Languages/30\Cube · high confidence

New game implementations have been added to the repository. This includes a C\# port of the card game Acey Ducey, a C\# implementation of the 'Guess the Animal' interactive quiz, a Java port of the number-guessing game Bagels, and a C\# version of the pile-taking strategy game Batnum. Each entry includes the necessary source code, project/solution files, and README documentation.

(repo-wide) · high confidence

The Salvo game is now available in C\# and Python, in addition to the existing BASIC, Java, JavaScript, Kotlin, Lua, Perl, and Ruby versions. The C\# port introduces a structured object-oriented design with dedicated classes for game logic (Game, TurnHandler), ship management (Fleet, Ship subclasses), and targeting strategies (ComputerShotSelector, HumanShotSelector). The Python port provides a functional implementation with type annotations. Both ports implement the core gameplay loop, allowing users to play the classic naval combat game in their preferred language.

_77\Salvo · high confidence

Introduced a new C\# implementation of the Bounce simulation, featuring a Game loop that accepts user parameters (time increment, velocity, elasticity) and renders a text-based graph of the ball's trajectory. The change includes the core logic for calculating bounce duration, maximum height, and plotting the trajectory over time, along with supporting classes for graph rendering and resource management.

_13\Bounce/csharp · high confidence

A new C\# implementation of the Hexapawn game has been added to the csharp/ directory. The code is structured into multiple classes including Board, Computer, Game, GameSeries, Human, Move, and others, utilizing the Games.Common.IO and Games.Common.Randomness libraries for input/output and randomness. The implementation includes a learning computer that remembers board positions and eliminates losing moves, mirroring the behavior of the original BASIC version. A solution file (Hexapawn.sln) and project files are also included to support building the C\# project.

_46\Hexapawn · high confidence

A new C\# implementation of the Awari board game has been added to the project. This includes the core game logic in Game.cs, a console-based user interface in Program.cs, and a solution file (Awari.sln) to support the build. The game allows a player to compete against a computer opponent, with the computer using a heuristic-based strategy to select moves. The implementation tracks game state, handles player and computer turns, and displays the board and game outcomes in the console.

(repo-wide) · high confidence

A new C\# port of the classic 'Stars' number-guessing game has been added to the 82\_Stars directory. This implementation includes the core game logic, a solution file for Visual Studio, and supporting resource files. The game challenges players to guess a random number between 1 and 100, receiving feedback in the form of stars indicating proximity to the target number. This adds a modern, object-oriented C\# version to the existing collection of ports in languages such as Python, Rust, JavaScript, and others.

_34\_Digits, 82\Stars · high confidence

A new C\# port of the classic 1970s city-management simulation is added to the project. The implementation includes a structured domain model (GameState, GameResult, PerformanceRating, ActionResult) and separates concerns into Controller, Rules, and View components. The game simulates a 10-year term where players manage land, grain, and population, with outcomes ranging from 'Terrific' to 'Disgraceful' based on starvation rates and acreage per person.

_43\Hammurabi · high confidence

A new C\# implementation of the 3-D Tic-Tac-Toe game has been added to the project. This includes the core game logic in \Qubic.cs\ and \QubicData.cs\, a \Program.cs\ entry point, and associated \README.md\ and \.sln\ files. The C\# port mirrors the existing Python, JavaScript, Java, and other language implementations, providing users with a .NET-compatible version of the classic game.

_88\_3-D\Tic-Tac-Toe · high confidence

A new C\# implementation of the 1968 Civil War simulation game has been added to the project. This port includes the core game logic (Army, Battle, GameOptions, Program), supporting utilities (ConsoleUtils), and a Visual Studio solution file, providing a modern, object-oriented alternative to the original BASIC source.

_27\_Civil\War · high confidence

The C\# implementation of the Cube game includes a command-line switch, --non-random, which allows the game to be run with deterministic mine locations for testing purposes, matching the behavior of the original BASIC program's randomization logic.

_30\Cube · high confidence

The Gunner game is now available in multiple programming languages, including C\#, Java, JavaScript, Perl, Python, Ruby, and Visual Basic .NET. Each port includes a README with source attribution and a porting note section. The implementations preserve the original game mechanics: players estimate elevation angles to hit a target within 100 yards, with up to 6 shots per enemy and 4 enemies per session. The JavaScript version includes an HTML wrapper for browser execution.

_42\Gunner · high confidence

New implementations of the Mastermind logic game have been added for C\#, Java, and JavaScript, each translating the original BASIC source into modern equivalents. The C\# port introduces structured classes for game logic, including a Code class for representing secret codes and a CodeFactory for generating permutations. The Java port implements a similar logic with a focus on memory management for the solution set. The JavaScript port provides a browser-based version with terminal-style output. All three ports preserve the core gameplay loop where the human guesses a computer-generated code, and the computer deduces the human's code using a process of elimination based on black and white peg clues.

_60\Mastermind · high confidence

Introduce the Checkers game implementation across several programming languages, including C\#, JavaScript, Java, Kotlin, Lua, Perl, Python, Ruby, and Visual Basic .NET, each with corresponding source files and README documentation. The original BASIC version is also included as an annotated version for readability. This adds new playable versions of the game in various modern languages, preserving the original game logic while adapting to each language's idioms and features.

_23\Checkers · high confidence

The classic 'Chief' math game is now available in multiple languages. A C\# implementation provides a structured, object-oriented version with separated game logic, math calculations, and UI resources. A JavaScript version adds a browser-based playable experience with a terminal-style UI. Lua, Perl, Python, Ruby, Rust, and VB.NET ports are also added, each translating the original BASIC game logic into their respective ecosystems. Additionally, a raw BASIC source file and a comprehensive README with porting notes are included.

_25\_Chief, 29\_Craps, 47\Hi-Lo · high confidence

Introduces the Chomp mathematical strategy game, originally from Scientific American (1973), with new implementations in C\#, Java, JavaScript, Perl, Python, and Visual Basic .NET, alongside the original BASIC source. Each port includes a README with porting notes and source files that replicate the game's core mechanics: a grid of squares where players alternately 'chomp' rows and columns, with the player forced to take the 'poison' square losing. The C\# version uses a dedicated Cookie class for board state, while Python uses a Canvas class, and JavaScript uses a simple array-based board. All versions support 1 or more human players, validate input, and allow replay.

(repo-wide) · high confidence

Users can now play the Craps game using MiniScript or Nim. The MiniScript port includes a README with instructions for running the game via command line or Mini Micro. The Nim port provides a native implementation of the same game logic. Additionally, a BASIC source file and a dice distribution analysis script are included in the directory.

_00\_Alternate\_Languages/29\Craps · medium confidence

A new D language implementation of the Time-Speed-Distance exercise has been added to the project. The program generates random car and train speeds and times, then prompts the user to calculate the car's travel time. It checks if the user's answer is within a 5% error margin and provides feedback on the accuracy of their calculation. The implementation includes a README file that credits the original source as Vintage Basic and notes the conversion to D.

_00\_Alternate\_Languages/91\Train/D · high confidence

The Dice simulation program is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, each with their own source files and README documentation. The original BASIC version is also included. This adds new language implementations for the Dice game, allowing users to run the simulation in their preferred language.

_33\Dice · high confidence

A new Elm-based implementation of the Acey Ducey card game has been added to the project. This includes the Elm source code (src/Main.elm), project configuration (elm.json), and build artifacts (docs/app.js, docs/app.min.js). The game allows players to bet on whether a third card's value falls between two dealt cards, with a starting bankroll of 100 units. The implementation handles game logic, state management, and UI rendering via the Elm architecture.

(repo-wide) · medium confidence

The Flip Flop puzzle game, originally published in Basic Computer Games (1978), is now available in multiple programming languages. New implementations have been added for C\#, Java, JavaScript, Lua, Perl, Python, Ruby, and Visual Basic .NET, each accompanied by a README explaining the conversion from the original BASIC source. The game challenges players to change a row of ten X's to O's by entering numbers, with the computer making random counter-moves.

_36\_Flip\Flop · high confidence

New implementations of the Change exercise have been added for the Go and MiniScript languages. The Go version provides a modern, typed implementation using standard libraries for input and math, while the MiniScript version offers a scriptable alternative. Both are located in the 00\_Alternate\_Languages/22\_Change directory alongside the existing BASIC source.

_00\_Alternate\_Languages/22\Change · high confidence

New language ports for the Hangman game have been added to the alternate languages directory. This includes a C implementation (main.c and dictionary.txt), a MiniScript version (hangman.ms with README), and a BASIC version (hangman.bas). Each file provides a distinct way to play the game in different programming environments.

_00\_Alternate\_Languages/44\Hangman · high confidence

The Hi-Lo guessing game is now available in three additional programming languages. A Go implementation (main.go) provides a standard library-based console experience. A MiniScript version (hi-lo.ms) includes a README with instructions for running the script via the command line or Mini Micro. A legacy BASIC version (hi-lo.bas) is also added. These new ports expand the range of languages in which users can play the game.

_00\_Alternate\_Languages/47\Hi-Lo · high confidence

The Java port of the classic 'High IQ' puzzle game is now available. The \HighIQ\ class implements the core game logic, including board state management, move validation, and win/loss condition checking. The \HighIQGame\ class provides the entry point, displaying instructions and enabling the user to play the game repeatedly by entering 'yes' to restart.

_48\_High\IQ/java · high confidence

A new Java implementation of the 'Animal' guessing game is added, featuring a tree-based data structure for questions and answers. The game allows users to play the classic guessing game, and includes a bonus option to view the game's question/answer data as a visual tree. A corresponding JUnit test file is also added to verify the game's behavior.

_03\Animal/java · medium confidence

Added JavaScript versions of several classic BASIC games, including Animal, Awari, Basketball, Batnum, Bombardment, and Bounce. Each game is provided with an HTML file that links to the corresponding JavaScript file and a shared terminal stylesheet, along with a README noting the original source from Vintage Basic. These additions expand the repository's collection of interactive, browser-based game implementations.

(repo-wide) · high confidence

A new JavaScript implementation of the classic Bagels game is now available. The port includes the core game logic in bagels.js, a corresponding HTML page (bagels.html) that loads the script and applies a terminal-style theme, and a README with source attribution.

_05\Bagels/javascript · high confidence

A multiple-choice quiz about children's literature is added, with implementations in C\#, JavaScript, Perl, Python, Ruby, Rust, and Visual Basic .NET, each accompanied by a README describing the source and conversion. The original BASIC source is also included, and a top-level README provides context and porting notes.

_57\_Literature\_Quiz, 76\_Russian\Roulette · high confidence

A new Lua implementation of the 'Animal' guessing game has been added to the 03\_Animal/lua directory. The port includes the core game logic in Animal.lua, which supports interactive play, listing known animals, and expanding the question tree with new animals, along with a README.md documenting the source and conversion.

_03\Animal/lua · high confidence

The Math Dice game, originally a BASIC title from Creative Computing, is now available in multiple modern languages. This update adds full implementations for C\#, Java, JavaScript (with an HTML wrapper), Python, Ruby, Rust, and Visual Basic .NET, each accompanied by a README explaining the conversion. The original BASIC source and a top-level README describing the game's educational purpose are also included.

_61\_Math\Dice · high confidence

Added new language implementations for the 3D Tic-Tac-Toe game in MiniScript and Classic BASIC. The MiniScript port includes a README with instructions for running the game via command-line MiniScript or Mini Micro. The BASIC port provides a text-based 4x4x4 cube game where players enter 3-digit coordinates to make moves. Both files are new additions to the alternate languages directory.

_00\_Alternate\_Languages/88\_3-D\Tic-Tac-Toe · high confidence

The 83\_Stock\_Market simulation is now available in MiniScript and Classic BASIC. Users can run the MiniScript version via the command line or Mini Micro, or execute the BASIC version directly. Both ports replicate the original stock market simulation, allowing users to buy and sell stocks with a $10,000 starting budget.

_00\_Alternate\_Languages/83\_Stock\Market · high confidence

Users can now play the One Check puzzle in MiniScript and Classic BASIC. The MiniScript port includes a README with instructions for running the game via command-line MiniScript or Mini Micro, while the BASIC port provides an alternative implementation. These additions expand the range of languages available for this puzzle, allowing users to choose their preferred scripting environment.

_00\_Alternate\_Languages/67\_One\Check · high confidence

The 00\_Alternate\_Languages/95\_Weekday directory now includes a MiniScript implementation (weekday.ms) and a BASIC implementation (weekday.bas) of the weekday calculator program, along with their respective README files. The MiniScript version provides a modern, object-oriented approach to calculating the day of the week and age statistics, while the BASIC version offers a traditional line-numbered script. Both versions allow users to input a date and receive information about the day of the week, age breakdowns, and retirement estimates.

_00\_Alternate\_Languages/95\Weekday · medium confidence

Added new language implementations for the Splat game. A MiniScript version (splat.ms) and its README are introduced, providing instructions for running the game via command-line MiniScript or Mini Micro. Additionally, a BASIC port (splat.bas) is added to the 00\_Alternate\_Languages/81\_Splat directory, alongside a new parent README.md that explains the purpose of alternate language ports.

(repo-wide) · high confidence

Users can now run the Banner program using MiniScript or Basic. The MiniScript version includes a README with instructions for running via command-line MiniScript or Mini Micro. The Basic version provides a legacy alternative implementation of the same functionality.

_00\_Alternate\_Languages/06\_Banner, 00\_Alternate\_Languages/21\_Calendar, 00\_Alternate\_Languages/58\Love · high confidence

Users can now run the Literature Quiz in MiniScript or Basic. The MiniScript port includes a README with instructions for the try-it page, command-line, and Mini Micro environments. The Basic port provides the original source code for the quiz.

_00\_Alternate\_Languages/57\_Literature\Quiz · high confidence

Added MiniScript and Go versions of the Even Wins game. The MiniScript port includes two programs: evenwins.ms, which plays deterministically, and gameofevenwins.ms, which features a computer opponent that learns from failures over multiple games. The Go implementation provides a modern, type-safe version of the game. Both new language ports are accompanied by updated README files with instructions on how to run the programs.

_00\_Alternate\_Languages/35\_Even\Wins · high confidence

The 41\_Guess program, a number guessing game, has been ported to new languages. A MiniScript implementation (guess.ms) and its accompanying README are added, providing instructions for running the game via command-line, Mini Micro, or the web try-it page. Additionally, a Go implementation (main.go) is introduced, offering a standard library-based approach to the same game logic. These additions expand the available ways to play the game beyond the original Basic version.

_00\_Alternate\_Languages/41\Guess · high confidence

Users can now play the Batnum game using MiniScript or Go. The MiniScript port includes a README with instructions for running the game via command-line MiniScript or Mini Micro. The Go port provides a compiled binary version of the game, allowing players to interact with the same 'Battle of Numbers' logic in a different environment.

_00\_Alternate\_Languages/08\Batnum · high confidence

The Math Dice game is now available in MiniScript and Pascal, in addition to the existing Basic port. Users can now play the dice game using the MiniScript interpreter or Mini Micro, or compile and run the Pascal version. The MiniScript port includes a README with instructions for running via the try-it page, command line, or Mini Micro. The Pascal port includes a README with translator notes and a Pascal source file that implements the same game logic.

_00\_Alternate\_Languages/10\_Blackjack, 00\_Alternate\_Languages/61\_Math\Dice · high confidence

The Word guessing game is now available in MiniScript and the original BASIC. Users can play the game via the command line or Mini Micro using the new MiniScript files, or run the classic BASIC version directly.

_00\_Alternate\_Languages/96\Word · high confidence

Users can now run the 45\_Hello interactive program using MiniScript. This includes the source code (hello.ms) and a README with instructions for running the program via the MiniScript command-line interface or Mini Micro.

_00\_Alternate\_Languages/45\Hello/MiniScript · high confidence

The 53\_King game now includes a new MiniScript implementation (king.ms) with a README explaining how to run it via command-line MiniScript or Mini Micro. Additionally, an updated BASIC version (king\_variable\_update.bas) provides clearer variable names and structure compared to the original king.bas, while the main README clarifies that alternate language ports are for educational purposes.

_00\_Alternate\_Languages/53\King · medium confidence

A new MiniScript implementation of the Mastermind game has been added to the alternate languages section. This includes the core logic in \mastermind.ms\ and a \README.md\ explaining how to run the game using either the command-line MiniScript interpreter or the Mini Micro environment.

_00\_Alternate\_Languages/60\_Mastermind, 00\_Alternate\_Languages/77\Salvo · high confidence

A new MiniScript implementation of the Nicomachus puzzle game has been added, allowing users to play the classic arithmetic guessing game using MiniScript's command-line interface, Mini Micro, or the web-based 'Try-It!' environment. The port includes the core game logic and a README with instructions for each platform.

_00\_Alternate\_Languages/36\_Flip\_Flop, 00\_Alternate\_Languages/64\Nicomachus · high confidence

A new MiniScript implementation of the 15\_Boxing game has been added to the alternate languages directory. This includes the source code (boxing.ms) and a README file explaining how to run the game using either the command-line MiniScript interpreter or the Mini Micro environment. The port preserves the original game's logic, including player and opponent name inputs, punch selection, and round-based win conditions.

(repo-wide) · high confidence

A new MiniScript implementation of the 91\_Train exercise has been added, including the source code (train.ms) and a README file explaining how to run the program via the web try-it page, command-line MiniScript, or Mini Micro.

_00\_Alternate\_Languages/91\Train/MiniScript · high confidence

Users can now run the Bounce simulation in MiniScript. A new MiniScript implementation (bounce.ms) and its README are added to the 13\_Bounce directory, providing command-line and Mini Micro execution options for this classic BASIC program.

_00\_Alternate\_Languages/13\Bounce · high confidence

Users can now play the classic Life and Life for Two games using the MiniScript language. This change introduces MiniScript implementations for both games, including the source code (.ms) and README files with instructions for running the games via command-line MiniScript or the Mini Micro environment.

_00\_Alternate\_Languages/55\_Life, 00\_Alternate\_Languages/56\_Life\_for\Two · high confidence

Users can now run three classic lunar landing simulations—lem, lunar, and rocket—in MiniScript. The new files include the source code (lem.ms, lunar.ms, rocket.ms) and a README explaining how to play via command-line MiniScript or Mini Micro. This adds a new scripting-language alternative for these specific games.

_00\_Alternate\_Languages/59\_Lunar\_LEM\Rocket · high confidence

The Rock, Scissors, Paper game is now available in three new alternate language implementations: a MiniScript script with usage instructions, a Bash shell script, and a Nim program. Each port replicates the original game logic, allowing users to play the classic game in their preferred scripting or systems language.

_00\_Alternate\_Languages/74\_Rock\_Scissors\Paper · high confidence

Users can now run the Buzzword generator in four additional languages: a new MiniScript implementation with updated README instructions, a Go port, a Nim port, and a Basic version. Each directory contains the source code and a README explaining how to execute the program in that specific language.

_00\_Alternate\_Languages/20\Buzzword · high confidence

The Depth Charge game is now available in three new language implementations: a Go version (go/main.go), a MiniScript version (MiniScript/depthcharge.ms with README), and a legacy BASIC version (depthcharge.bas). Each port includes its own README with instructions on how to run the game in that specific environment, allowing users to play the classic submarine-hunting game in their preferred language.

_00\_Alternate\_Languages/31\_Depth\Charge · high confidence

New implementations of the Tic-Tac-Toe game are added for MiniScript (tictactoe.ms, tictactoe2.ms), Pascal (tictactoe1.pas), and BASIC (tictactoe1.bas, tictactoe2.bas). These files provide alternative ways to play the classic game, each with their own README documentation explaining how to run the program in that specific language environment.

_00\_Alternate\_Languages/89\Tic-Tac-Toe · high confidence

New alternate-language implementations have been added for the Poetry and Poker games. The Poetry game now includes MiniScript, Perl, and Basic versions, while the Poker game now includes MiniScript and Basic versions. These ports allow users to play these classic text-based games using different scripting languages, with each port including its own README and source code files.

_00\_Alternate\_Languages/70\Poetry · high confidence

The Nicomachus arithmetic puzzle is now available in several programming languages, including C\#, Java, JavaScript, Python, Ruby, and Visual Basic .NET. Each port includes its own README and source files, with the original BASIC implementation also retained. The game challenges players to guess a number between 1 and 100 based on its remainders when divided by 3, 5, and 7.

_64\Nicomachus · high confidence

A new Nim source file (dice.nim) is added to the 00\_Alternate\_Languages/33\_Dice/nim directory. This file implements the Dice simulation, initializing a frequency array to zero before each run and using the random number generator to simulate rolling a pair of dice, then displaying the results.

_00\_Alternate\_Languages/33\_Dice/nim, 13\Bounce/ruby · high confidence

Introduces a new Nim source file (train.nim) that implements the 'Train' time-speed-distance exercise, generating random car and train speeds to calculate trip duration and checking user input accuracy.

_00\_Alternate\_Languages/91\Train/nim · high confidence

A new Perl module, BasicComputerGames::Hammurabi, has been added to provide the game logic for the classic resource management simulation. This implementation manages the game's state machine, handling player inputs for buying/selling land, feeding the population, and planting crops, while simulating annual events like rat infestations and harvest yields.

_43\Hammurabi/perl · high confidence

A new Perl implementation of the 'Bounce' simulation has been added to the 13\_Bounce directory. This port includes a README and the main bounce.pl script, which simulates the flight of a ball with specified initial velocity and elasticity. The Perl version adds a feature allowing users to quit the simulation by entering a TIME value of 0, and includes input validation to ensure the coefficient of elasticity is between 0 and 1.

_13\Bounce/perl · high confidence

The Python utility module now includes a dedicated CI environment for static analysis and type checking. A new \ci-requirements.in\ file lists the core tools (flake8, mypy, and specific flake8 plugins like flake8-bugbear and flake8-comprehensions), while the generated \ci-requirements.txt\ pins their exact versions and dependencies, ensuring consistent linting and type-checking in the continuous integration pipeline.

_00\Utilities/python · high confidence

Ported Python implementations for Acey Ducey, Amazing, Blackjack, Boxing, Bug, Bullseye, Checkers, Civil War, Even Wins, Golf, Hexapawn, and others, providing Python equivalents for the existing BASIC and other language versions.

python · high confidence

A new Python implementation of the classic 'Bagels' number-guessing game has been added to the project. The \bagels.py\ file provides a complete, interactive command-line experience where players attempt to guess a three-digit secret number, receiving clues (PICO, FERMI, or BAGELS) after each attempt. The code includes input validation, game logic, and a scoring system, effectively porting the original BASIC version to Python.

(repo-wide) · high confidence

A new Python implementation of the Bounce physics simulation is now available, allowing users to specify initial velocity, coefficient of restitution, and time increment to visualize a bouncing ball's trajectory. The program includes a header, instructions, and a text-based graphical representation of the simulation over time.

_13\Bounce/python · high confidence

New Ruby source files are added for four distinct programs: a maze generator (Amazing), an animal guessing game (Animal), a Blackjack model (CardKind and Player), and a Checkers game. The Blackjack model introduces support for insurance bets and split hands, while the Checkers implementation modernizes the original BASIC logic with object-oriented classes for the board and moves.

ruby · high confidence

A new Ruby implementation of the 'Batnum' game has been added to the repository. The addition includes a README explaining the source and conversion, and a \batnum.rb\ script that allows users to play a 'Battle of Numbers' game where they compete against the computer by removing objects from a pile according to specified rules.

_08\_Batnum/ruby, 12\_Bombs\_Away/javascript, 42\Gunner/rust · medium confidence

A new Ruby implementation of the classic Acey Ducey card game has been added, allowing users to play the simulation where they bet on whether the next card will fall between two dealt cards. The entry includes the main game logic in aceyducey.rb and a README with source attribution.

_01\_Acey\Ducey/ruby · high confidence

A new Rust implementation of the 95\_Weekday exercise has been added, providing a complete solution for calculating the day of the week for a given date. The code includes logic for parsing user input, validating dates, calculating the day of the week, and formatting output, effectively porting the functionality to Rust.

_95\Weekday/rust · high confidence

A new Rust port of the classic 'Animal' guessing game is now available in the 03\_Animal/rust directory. This implementation 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 with source attribution and the main.rs file containing the game logic and a B-Tree data structure for managing the question/animal database.

(repo-wide) · medium confidence

A new Rust source file (src/main.rs) has been added, providing a faithful translation of the classic 'Bunny' game from BASIC. This change introduces the game's logic and data structures, allowing users to play the text-based title within the Rust environment.

_19\Bunny/rust · medium confidence

A new Rust source file (src/main.rs) has been added, providing a faithful translation of the classic 'Hello' game. The program now supports interactive text-based gameplay where users can input their name and select from problem categories (Sex, Health, Money, or Job) to receive humorous, text-based advice, mirroring the behavior of the original BASIC version.

_45\Hello/rust · high confidence

A new Rust source file (main.rs) has been added to the 87\_3-D\_Plot/rust directory, providing a faithful translation of the classic 3D Plot game from BASIC to Rust. The implementation renders a 3D surface plot using ASCII characters, replicating the original algorithm's logic for calculating and displaying the plot.

_87\_3-D\Plot/rust · high confidence

A new Rust implementation of the Bounce simulation game has been added to the project. This faithful translation of the original BASIC program allows users to specify the initial velocity of a ball thrown straight up, the coefficient of elasticity, and the time increment for the simulation's 'stroboscopic' flight display. The program outputs a visual representation of the ball's trajectory using ASCII characters, calculating the height and time of each bounce based on the provided parameters.

_13\Bounce/rust · high confidence

A new Rust implementation of the Flip-Flop puzzle game has been added to the 36\_Flip\_Flop directory. The code introduces a Game struct that manages the board state, move history, and entropy, along with methods to flip characters, calculate move targets, and handle the game loop. The main entry point initializes the game, displays instructions, and runs the interactive loop, relying on the morristown library for input and output formatting.

_36\_Flip\_Flop/rust, 64\Nicomachus/rust · medium confidence

A new Rust source file (src/main.rs) provides a faithful translation of the classic BASIC Kinema game, simulating a ball thrown upwards with user input for velocity and time. The implementation corrects the original's mathematical simplifications by using precise float calculations for gravity (9.81 m/s²) and velocity, while preserving the original game's structure and output format.

_52\Kinema/rust · high confidence

The Sine Wave demo, originally published in Basic Computer Games (1978), is now available in multiple modern languages. This update adds new source files and project configurations for C\#, Java, JavaScript, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, each accompanied by a README explaining the conversion from the original BASIC version. The implementations preserve the classic alternating "Creative" and "Computing" text animation, with language-specific adjustments such as Python's timing delay for historical accuracy.

_78\_Sine\Wave · high confidence

The classic 1978 BASIC game 'Splat'—a parachute jump simulator where players try to open their chute at the last possible moment—is now available in multiple modern programming languages. This change introduces new source files and project configurations for C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and VB.NET, each accompanied by a README explaining the conversion from the original Vintage Basic source. The implementations preserve the original game mechanics, including random celestial body selection, terminal velocity calculations, and historical jump tracking.

_81\Splat · high confidence

The TRAP guessing game is now available in multiple languages. C\# and Rust implementations are added alongside existing ports in JavaScript, Perl, Python, and Ruby. Each language directory includes the source code and a README noting the original BASIC source from Vintage Basic. The game challenges players to trap a randomly generated number between 1 and 100 by entering two numbers, with six attempts to guess correctly.

_92\Trap · high confidence

This update introduces new ported versions of the classic Tic-Tac-Toe game across multiple programming languages. The diff adds complete source files and project configurations for C\# (including solution and project files), JavaScript (HTML/JS for browser play), Kotlin (with a dedicated Board class), Perl, Python (including a 'Hard' AI variant), Ruby, and Rust. Each implementation includes a README explaining the conversion from the original BASIC source. Additionally, a top-level README and language-specific READMEs are added to provide context and porting notes for each version.

_89\Tic-Tac-Toe · high confidence

Added new implementations of the Tower of Hanoi puzzle game, including a MiniScript version (tower.ms) with a corresponding README, and a Basic version (tower.bas). These files provide alternative language ports of the classic puzzle, allowing users to play the game using different scripting languages.

_00\_Alternate\_Languages/90\Tower · high confidence

The repository now includes a port of the classic two-player game NIM, originally from Basic Computer Games (1978). This change adds the original BASIC source code alongside new implementations in Python, JavaScript, C\#, Visual Basic .NET, Ruby, Perl, Lua, and Kotlin. Each language directory contains the source code and a README explaining the conversion from the original BASIC version.

_65\Nim · high confidence

Added a new Visual Basic .NET implementation of the 'Battle of Numbers' (Batnum) game, including the main program logic, solution file, and README. The game allows a player to compete against a computer opponent by removing objects from a pile, with configurable rules for winning conditions and move limits.

_08\Batnum/vbnet · high confidence

Added C++ and MiniScript implementations of the Sine Wave program, along with a Pascal port. Also added MiniScript and D implementations of the War card game, each with their own README and source files.

_00\_Alternate\_Languages/78\_Sine\Wave · high confidence

Users can now launch any of the 96 games directly in a web browser via a new index.html hub page that lists all titles with links to their JavaScript implementations. Additionally, a new HOW\_TO\_RUN\_THE\_GAMES.md file provides detailed instructions for running the games in various languages (C\#, Java, JavaScript, Kotlin, Pascal, Perl, Python, Ruby, Rust, and VB.NET), and a .coveragerc file is added to exclude test files from coverage reports.

(repo-wide) · high confidence

A new ANSI C program, hello.c, has been added to the 00\_Alternate\_Languages/45\_Hello/ANSI\_C directory. This file implements an interactive text-based simulation of a 'creative computer' that greets the user by name, asks about their well-being, and offers humorous advice on topics like job, money, health, and sex. The program handles user input validation and loops through various conversational branches, representing a shift in the 'Hello' example to include a more complex, stateful interaction rather than a simple print statement.

_00\_Alternate\_Languages/45\_Hello/ANSI\C · high confidence

The 59\_Lunar\_LEM\_Rocket directory now includes complete ported implementations of the classic lunar landing simulation in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Rust, alongside the original BASIC source files. Each language-specific folder contains the source code, a README crediting the original Vintage Basic source, and a solution file where applicable. The JavaScript ports also include HTML wrapper files for browser-based play. This expands the game's accessibility across modern development environments while preserving the original gameplay mechanics and physics.

_21\_Calendar, 49\_Hockey, 59\_Lunar\_LEM\Rocket · high confidence

The 80\_Slots game is now available in multiple new programming languages, including C\# (as a script), JavaScript (with an HTML interface), Ruby, and Visual Basic .NET. Each port includes its own README with source attribution and, where applicable, specific porting notes or build instructions (e.g., .NET Core SDK for C\#, dotnet-script tooling). The original BASIC source and existing ports (Python, Perl, Java, Kotlin, Lua) remain, expanding the game's accessibility across different developer ecosystems.

_80\Slots · high confidence

The 94\_War directory now includes new implementations of the classic card game War in C\#, D, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Rust, alongside updated or added documentation and project files for each. Each port provides a functional version of the game, with language-specific features such as C\# unit tests, Rust's rand crate for shuffling, and Perl's Unicode support for card suits.

_94\War · high confidence

Adds new ported implementations of the 'Letter' game, a classic guessing game where players try to identify a randomly selected letter of the alphabet. The update introduces source code and project files for C\#, Java, JavaScript, Python, Ruby, Rust, and Visual Basic .NET, each accompanied by a README explaining the conversion from the original BASIC source. Additionally, a main README and a terminal stylesheet for the JavaScript version are included.

_54\Letter · high confidence

A new CSS file (style\_terminal.css) is introduced to provide an old-school terminal aesthetic for the JavaScript utilities, featuring a green-on-black color scheme, monospace fonts, and visual effects like screen flicker and scanlines for desktop screens.

_00\Utilities/javascript · high confidence

Introduce the 'Word' game, a title from Basic Computer Games (1978) where players guess a five-letter word based on letter-position clues. This change adds the original BASIC source and new implementations in C\#, D, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and VB.NET, each accompanied by a README and language-specific build files (e.g., .sln, .csproj, .vbproj).

_96\Word · high confidence

The '06\_Banner' directory now contains implementations of the classic 'Banner' program, which creates a large text banner on the terminal. This change introduces the original BASIC source code alongside new ports in C\#, Java, JavaScript, Lua, Pascal, Perl, Python, Ruby, and Visual Basic .NET, each accompanied by a README explaining the conversion from the original 1978 Basic Computer Games source.

_06\Banner · high confidence

The '09\_Battle' directory now contains the 'Battle' game, a classic title based on Battleship, implemented across several languages including Python, Java, C\#, JavaScript, Ruby, and others. Each port provides a functional version of the game, allowing users to play the original 1971 BASIC game in their preferred language.

_09\Battle · high confidence

The Poetry game, which generates random verse in a style reminiscent of Edgar Allan Poe, has been implemented across several new language ports including C\#, Java, JavaScript, Python, Ruby, Perl, and Visual Basic .NET. Each port reproduces the original 1978 BASIC program's behavior, producing randomized poetic lines with specific probabilities for commas, spaces, and newlines. The C\# implementation introduces a \Context\ class to manage state and a \Poem\ class to orchestrate the generation loop, while other ports follow similar structural patterns to replicate the original game's output.

_70\Poetry · high confidence

Added four classic BASIC games from the 1978 'Basic Computer Games' collection, each with source code and documentation. 'Animal' is a guessing game where the computer asks questions to identify an animal the user is thinking of. 'Awari' is a digital version of the African board game involving sowing beans. 'Bagels' is a number-guessing game providing Pico, Fermi, and Bagels clues. 'Bounce' simulates the trajectory of a bouncing ball with configurable velocity and elasticity. Each game includes a README with rules, history, and porting notes.

(repo-wide) · high confidence

A new web-based terminal emulator has been added to the 00\_Common/javascript/WebTerminal directory, enabling users to play BASIC Computer Games directly in the browser. This includes the core JavaScript class (HtmlTerminal.js) and CSS styles (HtmlTerminal.css) that render a functional terminal interface with a blinking cursor, scrollable output, and input handling. The terminal supports multi-line text output, line breaks, and user input. A demonstration HTML page (terminal.html) loads game scripts via URL hashes and links to their source code on GitHub. Additionally, a shared JavaScript utility module (common.mjs) provides helper functions for terminal output (print, println, tab, input) used by the terminal and its tests.

_00\Common/javascript · high confidence

Users can now run the 'Amazing' maze generator in MiniScript, Go, and Pascal, each with their own implementation files and README instructions. The MiniScript version includes a README with command-line and Mini Micro usage instructions. The Go version provides a console-based maze generator. The Pascal versions include both an object-oriented implementation using Lazarus project files and a simple procedural version, both accompanied by project configuration and README files.

_00\_Alternate\_Languages/02\Amazing · high confidence

The 'Chief' number-guessing game has been added to the alternate language collection, with new source files for C (chief.c), Go (main.go), and MiniScript (chief.ms), each providing a port of the original BASIC program. Accompanying README files have been created to explain how to run the game in each environment, with the MiniScript version including specific instructions for the Try-It page, command-line, and Mini Micro platforms.

_00\_Alternate\_Languages/25\Chief · high confidence

The Rust source files for the 30\_Cube game have been added, introducing a new interactive text-based game where players navigate a 3D cube grid to reach a target coordinate while avoiding randomly placed landmines. The implementation includes game logic for movement validation, wagering, and wallet management, along with utility functions for input handling and random position generation.

_30\_Cube/java, 30\Cube/rust · high confidence

Introduced the Acey Ducey card game implementation (aceyducey.bas) along with a README.md containing game rules, source attribution, external links, and porting notes. The game simulates a card game where players bet on whether the next card will fall between two dealt cards, starting with $100.

_01\_Acey\Ducey · high confidence

Users can now play the Bombs Away game in Go and MiniScript. The Go implementation provides a modern, structured version of the game, while the MiniScript version offers a scriptable alternative. Both ports replicate the original game's mechanics, allowing players to choose sides (Italy, Allies, Japan, Germany) and experience the bomber mission gameplay in these new languages.

_00\_Alternate\_Languages/03\_Animal, 00\_Alternate\_Languages/12\_Bombs\Away · high confidence

A new Go version of the Dice program has been added to the project, providing a Go-language alternative for the dice-rolling simulation. This allows users to run the simulation using Go, mirroring the functionality of existing implementations in other languages.

_00\_Alternate\_Languages/33\Dice/go · high confidence

A new Go source file (main.go) has been added to the 00\_Alternate\_Languages/45\_Hello/go directory, providing a Go-language version of the Hello application. This adds a new language variant for users to explore or utilize within the alternate languages section.

_00\_Alternate\_Languages/45\_Hello/go, 78\_Sine\Wave/java · high confidence

Users can now play the Bullfight game using MiniScript or Classic BASIC. The MiniScript port includes a README with instructions for running the game via command-line MiniScript or Mini Micro. The BASIC port provides an alternative implementation of the same game logic. Both files are located in the 00\_Alternate\_Languages/17\_Bullfight directory.

(repo-wide) · high confidence

Users can now play the classic 'Bombardment' game using MiniScript or Go. The MiniScript version includes a README with instructions for running the game via command-line MiniScript or Mini Micro. The Go implementation provides a modern, compiled alternative with structured game logic and user prompts. Both ports are located in the 00\_Alternate\_Languages/11\_Bombardment directory.

_00\_Alternate\_Languages/09\_Battle, 00\_Alternate\_Languages/11\_Bombardment, 00\_Alternate\_Languages/34\Digits · high confidence

Added MiniScript implementations for the 37\_Football and 38\_Fur\_Trader programs, along with a Go implementation for 38\_Fur\_Trader. These new language ports allow users to run these classic games using MiniScript or Go, each with their own README and source files.

_00\_Alternate\_Languages/38\_Fur\Trader · high confidence

Users can now play the Civil War simulation using MiniScript. This change adds a new \MiniScript\ subfolder containing \civilwar.ms\ and its \README.md\ instructions, providing an alternative way to run the game alongside the existing BASIC version.

_00\_Alternate\_Languages/27\_Civil\War · high confidence

A new MiniScript implementation of the classic Hammurabi game has been added to the alternate languages collection. The port includes the main game logic in \hammurabi.ms\ and a \README.md\ with instructions for running the game via command-line MiniScript or Mini Micro. The implementation features a hidden hint function that can be uncommented to provide gameplay assistance, and the code structure mirrors the original BASIC version while adapting to MiniScript syntax.

_00\_Alternate\_Languages/18\_Bullseye, 00\_Alternate\_Languages/23\_Checkers, 00\_Alternate\_Languages/43\Hammurabi · high confidence

Users can now play the Letter guessing game and the Trap number-guessing game using MiniScript. Each game includes a \.ms\ source file and a \README.md\ with instructions for running the game via the MiniScript command-line tool, the Mini Micro environment, or the web-based "Try-It" page.

_00\_Alternate\_Languages/92\Trap · high confidence

Users can now play the Acey-Ducey game using a new Python script (acey\_ducey.py) accompanied by a README. The implementation provides the classic card game logic, allowing players to bet on whether a third card's value falls between two dealt cards, with support for cash management and input validation.

_00\_Alternate\_Languages/01\_Acey\_Ducey/go, 01\_Acey\Ducey/python · high confidence

Introduced a new Rust crate for the 32\_Diamond exercise, containing \lib.rs\ and \main.rs\. The library defines a \Config\ struct to handle user input for the diamond size and provides a \run\ function that prints a diamond pattern to the console. The main entry point initializes the configuration and executes the drawing logic, handling errors by exiting with a failure code.

_00\_Alternate\_Languages/33\_Dice/C, 32\Diamond/rust · high confidence

Added a new Rust source file (src/main.rs) that implements the 'Guess' game, where the computer selects a random number and the user attempts to guess it with feedback on whether the guess is too high or too low. The implementation includes a custom logarithmic calculation for determining the optimal number of guesses and uses the 'rand' crate for random number generation.

_41\Guess/rust · high confidence

A new Rust source file (src/main.rs) has been added to the 02\_Amazing/rust directory. This file contains the complete logic for generating and displaying a maze based on user-provided width and height. The program initializes a grid, randomly selects an entrance, and uses a depth-first search algorithm to carve paths through the maze. It then renders the maze to the console using ASCII art, allowing users to interact with the generator directly from the command line.

_02\Amazing/rust · high confidence

A new Rust utility has been added to generate a Markdown TODO list for the repository. The tool scans project directories to check for the presence of specific programming languages, allowing users to generate a status report of which games are implemented in which languages.

_00\_Utilities/markdown\_todo\rust · high confidence

A new Swift source file (hello.swift) was added to the 00\_Alternate\_Languages/45\_Hello/Swift directory, providing a complete implementation of the 'Hello' interactive text-based game. This allows users to run the game using the Swift programming language.

_00\_Alternate\_Languages/45\Hello/Swift · high confidence

The application now includes a complete VB.NET implementation of the 'Guess the Animal' game. The \Game\ class manages the interactive loop, handling user input for yes/no responses and branching logic. The \Branch\ class represents the decision tree nodes. A \ConsoleAdapter\ provides a concrete implementation for console I/O, including a \WriteCenteredLines\ method that centers text on the screen. The \Program\ entry point initializes the game. This adds a new playable feature to the project.

_03\Animal/vbnet/Animal · high confidence

The repository now includes additional ports of classic computer games to languages outside the primary ten, organized under the \00\_Alternate\_Languages\ directory. This change introduces implementations of 'Acey Ducey' in D and Object Pascal, 'Bagels' and 'Dice' in Basic, 'Tic-Tac-Toe' in Go, and 'Train' in Basic. These ports are intended for educational purposes, adhering to criteria of popularity, memory safety, and scripting nature where applicable.

(repo-wide) · high confidence

Added Java and Ruby implementations of several classic text-based computer games, including Awari, Bagels, Bombardment, Bullseye, Change, Chemist, Dice, Fur Trader, Guess, and Hammurabi. Each game is provided with a main entry point and supporting classes, preserving the original game logic and user interaction patterns.

(repo-wide) · high confidence

Visual Studio solution (.sln) files have been added for multiple VB.NET projects (Awari, Bagels, Basketball, Bombardment, Bombs Away, and Bounce). This ensures each project can be opened and built directly in Visual Studio, improving the developer experience for these specific game implementations.

(repo-wide) · high confidence

A new Perl implementation of the 'Bombs Away' game has been added, allowing users to pilot a WWII bomber across different theaters (Italy, Allies, Japan, Germany). The game features mission selection, combat mechanics involving gun and missile damage, and state leakage between missions that mimics the original BASIC version's behavior.

_12\_Bombs\Away/perl · high confidence

A new implementation of the 'Reverse' game has been added to the Rust directory. This is a faithful translation of a classic BASIC program, allowing users to play a puzzle game where they must sort a list of numbers by reversing segments of the array. The implementation includes the game logic, rules display, and win/loss conditions.

_73\Reverse/rust · high confidence

A new Rust implementation of the classic Nim game has been added to the project. This feature allows users to play a text-based version of Nim, where they can choose to go first or let the computer move first, select the number of piles and their sizes, and play against an AI opponent that follows specific win/loss conditions. The implementation includes logic for both human and computer turns, handling game states and win conditions.

(repo-wide) · high confidence

The Rust implementation of the 90\_Tower project now includes the core game logic for the Towers of Hanoi puzzle. This adds the ability to play the classic puzzle where players transfer disks between three needles, with the game tracking moves and validating that larger disks are never placed on smaller ones. The update introduces the \Disk\, \Needle\, and \Game\ structs along with a \util\ module for input handling, enabling the interactive command-line experience.

_90\Tower/rust · high confidence

The Rust source files for the Splat simulation game have been added, introducing the game's core logic. This includes the game loop and state management in game.rs, a celestial body module defining planetary acceleration values, a stats module that persists and ranks player jump altitudes to a local file, and utility functions for input handling and randomization. The main entry point ties these components together to run the parachute jump simulation.

_81\Splat/rust · high confidence

The directory now includes two Perl implementations of the basketball game: a 'faithful' translation (basketball-orig.pl) that retains the original structure with GOTO statements, and a 'modern' translation (basketball.pl) that restructures the code into subroutines to eliminate GOTOs while preserving the same game mechanics and probabilities.

_07\Basketball/perl · high confidence

The 00\_Utilities folder now includes a README.md explaining its purpose, a TODO.md checklist tracking implementation status across multiple languages, and several helper scripts: a Python script (markdown\_todo.py) to generate the TODO list, a Node.js script (build-index.js) to create an index.html for all games, a Node.js script (find-missing-implementations.js) to identify unimplemented games by language, a Perl script (bas2perl.pl) to convert BASIC files to Perl, and a Perl script (yatol.pl) to list unimplemented games. Additionally, a Notepad++ syntax highlighting file (VintageBASIC.xml) was added.

_00\Utilities · high confidence

The Blackjack game has been implemented in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, each with their own README and source files. The Java implementation includes unit tests for the deck, game logic, scoring utilities, and user input handling.

_10\Blackjack · high confidence

A new C\# implementation of the classic Super Star Trek game has been added to the project. This port includes the core game logic, including the Enterprise, Klingons, and Starbases, as well as the command system and user interface. The implementation features a structured object-oriented design with separate classes for game states, spaces, and resources, providing a modern C\# alternative to the existing BASIC and Python versions.

_84\_Super\_Star\Trek · high confidence

A new Rust implementation of Conway's Game of Life has been added, allowing users to input a grid pattern and watch the simulation run, with the board automatically shrinking to fit the active cells.

_55\Life/rust · high confidence

The 55\_Life directory now includes full implementations of Conway's Game of Life in multiple languages, each accompanied by a README. The C\# and Python ports feature a --wait argument to pause between iterations, while the Java port adds a -s argument for step-by-step execution. The Rust port includes a half-second pause between generations and handles invalid inputs gracefully. All ports preserve the original BASIC behavior, including the dot-prefix for leading spaces and case-insensitive DONE detection.

_55\Life · high confidence

The C\# source files in the 07\_Basketball/csharp directory have been added, providing a complete translation of the original game's mechanics into C\#. This includes the core game loop, a Clock to manage game time and overtime conditions, a Scoreboard to track and display team scores, and classes for handling shots, defense, and team plays. The implementation also includes embedded resource files for game text and a solution file to support building the project.

_07\Basketball/csharp · high confidence

A new .NET common library (Games.Common) is added to the project, providing reusable components for game input/output and random number generation. The library includes a TextIO class for managing text input and output (with a ConsoleIO concrete implementation), an IRandom interface and RandomNumberGenerator implementation for BASIC-style random number operations, and supporting interfaces like IReadWrite. This allows C\# and VB.NET game ports to share common functionality, with the 86\_Target project now referencing this common library.

_00\Common/dotnet · medium confidence

Added a new randomness abstraction in the Games.Common.Randomness namespace, featuring the IRandom interface with NextFloat, PreviousFloat, and Reseed methods, along with a concrete RandomNumberGenerator class that wraps the standard .NET Random. Extension methods on IRandom provide convenient range-based NextFloat and Next overloads for floats and integers, enabling consistent random number generation across the codebase.

_00\Common/dotnet/Games.Common/Randomness · high confidence

A new Rust-based implementation of the Blackjack game has been added, featuring core gameplay mechanics including card handling, hand evaluation, betting, and player actions such as hitting, standing, doubling down, and splitting. This provides a functional, albeit incomplete (missing splitting logic per the TODO), version of the game in Rust.

_10\_Blackjack/rust, 51\Hurkle/rust · high confidence

Added the Java source file for the Buzzword application, which initializes a Scanner for input, creates a BuzzwordSupplier, and runs the UserInterface to process user input.

_20\Buzzword/java · high confidence

A new MiniScript port of the classic Super Star Trek game has been added to the Alternate\_Languages/84\_Super\_Star\_Trek/MiniScript directory. This port includes a README with usage instructions for both command-line MiniScript and Mini Micro environments. Notably, the game's instructions, which were originally in a separate BASIC program due to memory constraints, have been integrated directly into the main MiniScript program, allowing players to access the help text at the start of the game or via the HLP command.

_00\_Alternate\_Languages/84\_Super\_Star\Trek · high confidence

A new MiniScript implementation of the Bagels number-guessing game has been added to the repository. This includes the core game logic in bagels.ms and a corresponding README.md with instructions for running the game via command-line MiniScript or Mini Micro.

_00\_Alternate\_Languages/05\_Bagels/MiniScript, 11\Bombardment/perl · high confidence

Users can now run the Dice simulation in MiniScript, a lightweight scripting language. The new implementation includes a command-line version, a Mini Micro version, and a web-based 'Try-It!' option, allowing players to simulate rolling a pair of dice and view the frequency of each total from 2 to 12.

_00\_Alternate\_Languages/33\Dice/MiniScript · high confidence

Added MiniScript implementations for the Horserace and Hurkle games, each accompanied by a README explaining how to run the scripts via the command line or Mini Micro. The Horserace port adjusts the track length for modern screens and uses VT100 escape sequences for screen clearing, while the Hurkle port provides a grid-based guessing game with directional hints.

_00\_Alternate\_Languages/50\_Horserace, 00\_Alternate\_Languages/51\Hurkle · high confidence

The repository now includes new implementations of the Gunner game in MiniScript, Go, and BASIC. Users can now play the game using these specific languages, with each port including its own README and source files. The MiniScript version provides both command-line and Mini Micro execution options, while the Go version offers a standard library-based CLI experience. These additions expand the range of programming languages available for the educational game.

_00\_Alternate\_Languages/42\Gunner · high confidence

A new \Games.Common.IO\ library has been introduced to standardize input and output operations across games. This includes an \IReadWrite\ interface and a \TextIO\ base implementation that replicates Vintage BASIC-style input behavior, including tokenization, number parsing, and string handling. The library provides specific methods for reading and writing characters, numbers, and strings, along with a \ConsoleIO\ implementation for standard input/output. This change enables consistent user interaction patterns across different game implementations.

_00\Common/dotnet/Games.Common/IO · high confidence

The '68\_Orbit' directory now includes new language-specific implementations of the classic 'Orbit' game, including C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Rust. Each port preserves the original game's mechanics, where players must destroy a cloaked Romulan ship by calculating bomb trajectories using the law of cosines. The updates also include corresponding README files for each language, documenting the source and conversion details.

_68\Orbit · high confidence

The 'Weekday' program, originally a BASIC title from Basic Computer Games (1978), is now available in multiple modern languages. Users can run the application in C\#, Java, JavaScript (with a provided HTML shell), Kotlin, Lua, Perl, Python, Ruby, Rust, or Visual Basic .NET. Each port includes a README with source attribution and porting notes, and the implementations preserve the original logic for calculating the day of the week, age, and estimated time spent sleeping, eating, working, and relaxing.

_95\Weekday · high confidence

The 23 Matches game has been ported to C\#, Java, JavaScript, Python, Ruby, Rust, and Perl, each with their own implementation files and README documentation. The original BASIC version remains available, and each port preserves the core gameplay: players take turns removing 1-3 matches from a starting pile of 23, with the goal of not taking the last match.

_02\_Amazing, 93\_23\Matches · high confidence

Added a Perl implementation of the 75\_Roulette game, including the main script (roulette.pl), a test suite (roulette-test.t) that verifies payout logic against the original BASIC, and a test generator script (make-roulette-test.pl).

_75\Roulette · high confidence

The Awari game has been ported to Ruby, implemented as a \Game\ class that encapsulates the game logic, state, and UI rendering. The conversion includes a custom input parser to handle Vintage Basic-style string and comma-separated inputs, and a structured game loop that manages player and computer turns, move validation, and win/draw conditions.

_04\Awari/ruby · high confidence

The core game logic for the 12\_Bombs\_Away title has been implemented in Rust. This includes the definition of player sides (Italy, Allies, Japan, Germany) with specific target options and briefing messages, a side selection mechanism, and the main mission loop that determines success or failure based on mission count and random chance.

_12\_Bombs\Away/rust · medium confidence

The Bombs Away game is now available in a Lua implementation. This new version includes a README explaining the conversion from the original Vintage Basic source and provides the full game logic in Lua, supporting the same gameplay mechanics as previous ports.

_12\_Bombs\Away/lua · high confidence

Users can now play a text-based basketball simulation game originally from Vintage Basic, now converted to Python. The game allows players to act as Dartmouth's captain and playmaker, choosing shot types and defensive formations to simulate game outcomes.

_07\Basketball/python · high confidence

A MiniScript implementation of the Number game has been added to the alternate languages collection. This port includes the source code (number.ms) and a README with instructions for playing via Command-Line MiniScript, Mini Micro, or the web-based 'Try-It!' environment.

_00\_Alternate\_Languages/66\Number · high confidence

Added new implementations of the classic draw poker game in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Visual Basic .NET. Each port preserves the original gameplay mechanics, including betting, drawing, and hand evaluation, while adapting the code structure and user interface to modern standards for each respective language.

_71\Poker · high confidence

Added Java implementations of several classic BASIC games, including Acey Ducey, Blackjack, the Civil War simulation, Conway's Game of Life, and a Buzzword generator. These files introduce new game logic, UI components, and supporting classes (such as Card records and enums) to recreate the original programs' look and feel while fixing original bugs and leveraging modern Java features like records and text blocks.

. · high confidence

The 72\_Queen game has been ported to Rust, implementing the core game logic in src/game.rs, the computer opponent's strategy in src/ai.rs, and the user interface and input handling in src/util.rs and src/main.rs. This provides a native Rust implementation of the chess-based board game where players and the computer alternate moves to place a queen on a board.

_12\_Bombs\_Away/java, 50\_Horserace/rust, 72\Queen/rust · high confidence

The Acey Ducey card game has been ported to Lua, allowing users to play the classic betting game where they predict if a third card's value falls between two dealt cards. The implementation includes the full game logic, including betting mechanics, card value handling, and game state management in Lua.

_00\_Alternate\_Languages/01\_Acey\_Ducey/MiniScript, 01\_Acey\Ducey/lua · high confidence

A Java implementation of the 'SPLAT' game, originally created by John Yegge and ported from BASIC, is now available. The application simulates a parachute jump where the player must time their parachute deployment to avoid a 'splat'. Users can choose their own terminal velocity and acceleration due to gravity, or let the computer select these values. The game tracks past successful jumps and provides feedback on the player's performance relative to previous attempts.

_81\Splat/java · high confidence

Added a new Perl implementation of the 'Animal' guessing game, which allows users to play an interactive game where the computer guesses an animal by asking yes/no questions. The entry includes the main script (animal.pl) and a README file.

_03\Animal/perl · high confidence

The classic 'Reverse' game, originally from Basic Computer Games (1978), is now available in multiple languages. This change adds new implementations for C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and VB.NET, each including their respective project files, source code, and README documentation. The C\# port also includes a comprehensive test suite using FsCheck and xUnit to verify the core reversing logic and edge cases.

_73\Reverse · high confidence

The '28\_Combat' directory now includes full implementations of the classic 1978 BASIC game 'Combat' in five new languages: C\#, Java, JavaScript, Perl, and Python. Each port preserves the original game's mechanics, including the specific bugs and quirks of the source code, while adapting the user interface and input handling to modern standards. The C\# version introduces a structured object-oriented design with state management, while the other ports provide direct translations of the original logic.

_28\Combat · high confidence

The Bullseye game, originally published in Basic Computer Games (1978), is now available in multiple modern languages. This change adds full implementations in C\#, JavaScript, Kotlin, Lua, Perl, Python, Ruby, Rust, and Visual Basic .NET, each accompanied by a README explaining the source and conversion. The original BASIC source and a Markdown file with porting notes are also included.

_18\Bullseye · high confidence

The classic 1978 BASIC game Gomoko is now available in C\#, Java, JavaScript, Lua, Perl, Python, Ruby, and Visual Basic .NET, each with their own README and project configuration files. This provides users with the ability to play the game in their preferred programming environment.

_40\Gomoko · high confidence

The classic 'King' simulation game is now available in C\#, Java, and JavaScript, each with their own implementation files and documentation. The C\# version includes a full object-oriented structure with separate classes for Game, Country, Reign, and Year logic, along with embedded resource files for all text strings. The JavaScript version provides a browser-based playable version via an HTML file. All ports include a README with porting notes and source attribution.

_53\King · high confidence

Added implementations of the 'Number' game in C\#, Java, JavaScript, Python, Ruby, Rust, and Visual Basic .NET, alongside their respective project files and README documentation. Each port translates the original BASIC logic into the target language's standard libraries and syntax, providing users with the ability to play the game across a wide range of platforms and environments.

_66\Number · high confidence

The Pizza game, originally from Basic Computer Games (1978), is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Rust, each with their own implementation files and README documentation.

_69\Pizza · high confidence

The classic 'Queen' game, originally published in Basic Computer Games (1978), is now available in multiple new implementations. This adds C\# and Java source code, a JavaScript web version, and ports in Perl, Python, and Visual Basic .NET, each accompanied by a README explaining the conversion source and target language.

_72\Queen · high confidence

The classic 1978 slalom simulation is now available in multiple languages, including C\#, Java, JavaScript, Python, Ruby, and VB.NET. Each port preserves the original gameplay—selecting gate count, speed, and handling race outcomes—while adding a documentation of a known bug in the original BASIC version where the data pointer does not reset after a race, which can cause errors in subsequent races.

_79\Slalom · high confidence

The Stock Market simulation game has been ported to C\#, Java, JavaScript, Kotlin, Lua, Perl, and Ruby, each with their own implementation files and README documentation. The C\# port includes a structured codebase with separate classes for game logic (Broker, Controller, StockMarket), data models (Assets, Company, TradingDay), and UI (View). The Java, JavaScript, Kotlin, Lua, Perl, and Ruby ports provide equivalent functionality in their respective languages, enabling users to play the classic stock market simulation in their preferred environment.

_83\_Stock\Market · high confidence

The Tower of Hanoi puzzle, originally from a 1978 BASIC game, is now available in multiple modern languages. This change adds new implementations in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, and Ruby, each accompanied by a README explaining the source and conversion. The C\# port includes a structured project with models, UI, and resources; the Java port provides a single-file implementation; the JavaScript port uses a terminal-style HTML interface; and the Python, Lua, Perl, and Ruby ports each offer their own idiomatic translations of the classic logic puzzle.

_90\Tower · high confidence

The Train game, originally a BASIC program from 1978, is now available in multiple modern languages. This change adds new implementations in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Rust, each accompanied by a README explaining the conversion source and target language. The C\# and VB.NET ports also include Visual Studio solution and project files, with C\# including a corresponding test suite. The core gameplay remains consistent: the user calculates the time for a car trip based on speed and time differences, with the computer verifying the answer within a 5% margin of error.

_32\_Diamond, 91\Train · high confidence

Added a new port of the classic 'Bullfight' game, originally from Basic Computer Games (1978), to C\#, Java, JavaScript, Python, Kotlin, Lua, and Perl. Each port includes a README with source attribution and porting notes, and the C\# implementation introduces a structured event-based architecture with a mediator pattern to separate game logic from user input handling.

_16\_Bug, 17\Bullfight · high confidence

The 'Target' game—originally from Basic Computer Games (1978)—is now available in multiple modern languages. This change adds the C\# implementation (with supporting classes like Angle, Explosion, FiringRange, Game, Offset, Point, and Program), a Java version, a JavaScript/HTML5 version, a Python version, a Perl version, and a Visual Basic .NET version, each with their own README and build/solution files. Users can now play the 3D shooting simulation in their preferred language, with each port preserving the original gameplay mechanics: estimating target coordinates, firing shots, and receiving feedback on accuracy.

_86\Target · high confidence

The classic BASIC game Football is now available in C\#, Java, JavaScript, Python, Ruby, and Visual Basic .NET, each with their own README and project/solution files. The original BASIC source files (football.bas, ftball.bas) are also included. This allows users to play the game in their preferred modern language environment.

_37\Football · high confidence

The 'Life for Two' game, originally published in Basic Computer Games (1978), has been ported to multiple languages. The C\# implementation introduces a structured object-oriented design with separate classes for Board, Game, Generation, and Piece, while the Java, JavaScript, Python, Ruby, and VB.NET versions provide alternative implementations of the same two-player competitive Game of Life variant. The C\# code specifically encapsulates the board state, neighbor counting, and game loop logic into distinct components, whereas the other ports follow more procedural or script-based approaches. All versions include README files with source attribution and porting notes.

_56\_Life\_for\Two · high confidence

Added the 1978 'Basic Computer Games' title 'Basketball', a simulation where the player controls Dartmouth College's captain, choosing from four shot types and adjusting defense strategies. The port includes a new README with game rules, source code, and specific porting notes detailing original bugs (such as defense selection skipping) and preserved quirks.

_07\Basketball · high confidence

Added a Python implementation of the Bombs Away game, including the main game logic, player interactions, and mission scenarios for different historical contexts such as Italy, Allies, Japan, and Germany. The Python version mirrors the original BASIC game's mechanics, allowing users to experience the game in a modern programming environment.

_08\_Batnum/rust, 12\_Bombs\_Away/python, 76\_Russian\Roulette/rust · medium confidence

The classic kinematics quiz game KINEMA is now available in C\#, Java, JavaScript, Kotlin, Lua, Perl, Python, Ruby, and Visual Basic .NET, each with their own README and source files. The original BASIC source is also included, and a top-level README explains the game's rules and history.

_52\Kinema · high confidence

The 'Depth Charge' game, originally published in Basic Computer Games (1978), is now available in C\#, Java, JavaScript, Python, Ruby, Perl, and Visual Basic .NET. Each port preserves the original gameplay mechanics, including the sonar-based feedback system that reports the relative direction and depth of the player's shots. The C\# and Java implementations include input validation to prevent crashes from invalid entries, while the JavaScript version provides a browser-based interface. Each language folder includes a README with conversion notes and source attribution.

_31\_Depth\Charge · high confidence

The game is now available as a Rust application, featuring the core gameplay loop including navigation, combat (phasers, torpedoes, shields), scanning, and damage control. The implementation includes a text-based UI with instructions, status reports, and game-over conditions.

_84\_Super\_Star\Trek/rust · high confidence

The Rust source file for the King game has been added, implementing the core game loop, state management, and user interaction logic. This provides a new Rust-based version of the game, handling the round-based gameplay, player inputs, and state transitions as defined in the code.

_53\King/rust · high confidence

Added the Visual Basic .NET solution file (Animal.sln) which defines the main Animal project and a new Animal.Tests xUnit test project, alongside a README.md that explains the conversion from the original BASIC source and notes the use of a console abstraction for potential UI variations.

_03\Animal/vbnet · high confidence

Users can now play the classic Acey Ducey card game in Elixir. The implementation simulates the game where the player bets on whether the next card's value falls between the first two dealt cards. The game tracks funds starting at $100 and continues until funds are lost. A recent fix corrected the win condition to use a stricter, non-inclusive range check (floor \< third \< ceiling) rather than the looser inclusive check.

_01\_Acey\Ducey/elixir · medium confidence

The Acey Ducey game implementation has been refactored from a legacy structure into a modern Visual Basic .NET application. The code now utilizes subroutines and functions to eliminate nested loops and GOTO statements, resulting in cleaner, more maintainable logic. Additionally, the betting mechanism now includes robust input validation to ensure wagers are valid integers within the player's current balance.

_01\_Acey\Ducey/vbnet · high confidence

The 09\_Battle application has been ported to Rust. This change introduces a new Rust implementation for the battle game logic, including ship placement, coordinate handling, and game state reporting, replacing the previous implementation in this directory.

_09\Battle/rust · medium confidence

The Mastermind game has been refactored from a single-file script into a modular Rust project. The logic is now split between \lib.rs\, which contains the core game mechanics and configuration handling, and \main.rs\, which manages the entry point and user greetings. This change improves code organization and separates concerns, making the game logic easier to maintain and test.

_60\_Mastermind/rust/Mastermind\_refactored\_for\conventions · high confidence

The logic for resolving basketball plays has been restructured into specific classes: BallContest, HomeTeamPlay, VisitingTeamPlay, and a base Play class. This change encapsulates the probabilistic outcomes for shots, rebounds, and fouls within these new components, separating the home and visiting team play logic and introducing a shared BallContest mechanism for contested shots.

_07\Basketball/csharp/Plays · medium confidence

Added BASIC test scripts for input, output, and random number generation; Added ConsoleTest abstract class for testing console interactions; Added test coverage for the Animal guessing game; Added tests for the new TextIO, Token, and Tokenizer components; Enables internal access for unit tests.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 46.

• Code Health 42
• Architecture 94
• Maturity 40
• Readiness 51
• Security 58

• 300 commits — 278 feature/other, 22 fixes

• (repo) — 80 commits
• (root) — 17 commits
• 00_Alternate_Languages/93_23_Matches — 9 commits
• 00_Alternate_Languages/45_Hello — 7 commits
• 13_Bounce/rust — 5 commits
• 00_Alternate_Languages/01_Acey_Ducey — 4 commits
• 00_Alternate_Languages/10_Blackjack — 4 commits
• 00_Alternate_Languages/59_Lunar_LEM_Rocket — 4 commits
• 00_Alternate_Languages/86_Target — 4 commits
• 00_Alternate_Languages/89_Tic-Tac-Toe — 4 commits
• 00_Alternate_Languages/96_Word — 4 commits
• 00_Alternate_Languages/73_Reverse — 3 commits
• 00_Alternate_Languages/80_Slots — 3 commits
• 00_Alternate_Languages/81_Splat — 3 commits
• 00_Alternate_Languages/82_Stars — 3 commits
• 00_Alternate_Languages/84_Super_Star_Trek — 3 commits
• 00_Alternate_Languages/85_Synonym — 3 commits
• 00_Alternate_Languages/90_Tower — 3 commits
• 00_Alternate_Languages/95_Weekday — 3 commits
• 01_Acey_Ducey/python — 3 commits

• fix: Acey Ducey fixes for #869
• fix: Add documentation for tourist trade bug in King
• fix: Added MiniScript implementation of Bombardment and Bombs Away. Also fixed a minor issue with Blackjack.
• fix: Added MiniScript version of 88_3-D_Tic-Tac-Toe. (Also fixed a bug in the JavaScript port.)
• fix: Bug fixes and tweaks to MiniScript blackjack.
• fix: Fix bug in Lunar: wrong capsule weight. Must be 32500 lbs, not 33000.
• fix: Fix bug in win?/3
• fix: Fix flake8 issues in acey ducey
• fix: Fix missing array clear in Dice
• fix: Fix pick of pollution reason in python King
• fix: Fix random logic in Nim ports
• fix: Fixed README for 45_Hello/MiniScript.
• fix: Fixed README for MiniScript Chomp.
• fix: Fixed some minor issues with weekday.ms.
• fix: Fixed/elaborated two MiniScript README files.
• fix: Fixes the type check failures for python implementations, boxing.py and Stock_Market.py
• fix: Merge pull request #934 from dnellis74/bugfix/update-book-link
• fix: Nim code more idiomatic; fix errors
• fix: Revert "Fix bug in Lunar: wrong capsule weight."
• fix: Revert "Port 06_Banner to Rust"
• …and 280 more

• 1 containers · 3 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

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.