Trying to find a truly ancient computer game from vague memory

To set the age of the game, I played it on my oldest brother’s hand-built Altair(some number) computer when that was cutting edge. You booted the thing by flipping a whole series of switches on the case – it took several minutes, even though he had the sequence memorized. The game itself might have been typed in from a printout in a computer fan magazine, though then it could be stored and loaded via the high tech breakthrough of storing on a tape on a basic cassette recorder.

I cannot recall what the game was called, and unfortunately Eldest Brother is long dead. (Though the Altair still sits in a box in the attic…)

The game was in black and white ((actually his screen was green and white.) There was one or multiple targets (depending on the level) represented I think by a white dot, maybe an asterisk or just a little circle. There were other white dots, several sizes, that were sort of little spiky balls.

The game play consisted of clicking on or very near a white dot, which acted as it you’d transfered energy to the dot. and made it move around the screen in sort of mechanically believable paths. Like, if you clicked at six o’clock to the dot, it would move towards the top of the screen. Clicking closer made the dot go faster, a bit further away it went slower. You could click near a moving dot to cause its path to warp appropriately. If your moving dot hit the edge of the screen it rebounded. It your dot hit another, they would affect each other, or sometimes get stuck together.

The goal was to get your dot to run into the target circle(s) which would sort of eat them. You had some limit, I don’t remember if it was number of clicks or time elapsed, to feed all the dots to the targets.

Believe it or not, I remember it being fun to play! But hey, this was just slightly after people would spend hours playing Pong.

Does this ring any bells for anyone? Maybe I could find it if I knew the title – they say the Internet never forgets!

I don’t recognize rhe game, but I recognize the computer.

Gemini says “Target”:

The game you are thinking of is Target, a classic text-based or minimal character-graphics game that was adapted for the MITS Altair 8800 microcomputer in 1976. [1, 2]

How the Game Worked

  • The Gameplay: The game rendered a very simple playing area using character symbols (like a period or asterisk .) to represent a “dot” or missile, and another symbol to represent a target.
  • The Goal: Players used specific keys to change the trajectory or position of the moving dot across the terminal interface to make it successfully hit the target.

Yikes, classic good news/bad news. Someone else remembers the game and its name … but the name is the same as a chain of retail stores! All those “Target is having a computer game sale” links are totally swamping what I’m looking for. :frowning:

Nevermind. I will persist! Thanks for your help.

Well, including terms like “Altair” in your search narrows it down considerably.

The May 1976 issue of “Computer Notes” references it, seems they had a separate mailing for the actual listings however.

Looks like it would have been 197 bytes, which is barely longer than the first two sentences of this reply I’m typing to you now? Games have sure become bloated in the 50 years since…

Type a description of the game, with references to the Altair, the game play, etc., into one of the LLMs and have it spit out a playable HTML version of the game. The result will be more than 197 bytes…

ETA: I just clicked on that Computer Notes link and, man, does that bring back memories of being a home computer hobbyist. My drug of choice was the Apple ][, not the Altair, though.

Looks like it’s here, you can order the source listing from this enthusiast page:

Scroll down to “Altair Software Library Update,” under “Altair software and miscelaneous” [sic]

" Target is a 9-page listing using a VDM video display and “bit 7 of an input device” (front panel?)."

 Altair Software Library update, 60 pgs
    short descriptions of several dozen programs, coding sheet,
    source listings of: JAMON, kill the bit, target.
    JAMON is five pages of code listings. Commands are to load
    and dump and "go", all in octal (bleah). Kill the bit is a
    one-page listing of a game using the front panel only.
    Target is a 9-page listing using a VDM video display and
    "bit 7 of an input device" (front panel?).

Not sure what he charges, but presumably worth it for a bit of nostalgia and the memories of playing with your late older brother.

Odd that you posted this request, I was just shopping for an Altair kit/replica yesterday.

Have fun!

If you found the game, I seriously doubt you could find a machine to run it. When Windows went to a 32bit platform, it had a tool that could run 16-bit apps via NTVDM (NT Virtual DOS Machine) and WOW (Windows on Windows). You could play some really old games right in Windows. Unfortunately, when Windows went to a 64 bit platform, those options no longer exist.

The DOSBOX Emulator should run anything , 16 bit or 32 bit, if I’m not mistaken.

I’ll keep that in mind! I think a lot of those old games are really neat.

Interesting how our memories get warped… You remembered it as “clicking” near the dots, even though that was well before the computer mouse came into use. But that’s now so much the default way of interacting with computers, that your memory applied it to pre-mouse games as well.

How sure are we the the Target games are it? Their descriptions don’t really seem to match. And yeah, the Altair under normal setups didn’t seem like it would be the right platform for this type of game. Sure it wasn’t an Atari or something else?

Maybe he or she meant clicking a switch, but not a mouse button.

Not 8080 or Z80-based CP/M programs. And those are 8 bits. In fact, DOSBox is mainly designed to run MS-DOS binaries, not at all “anything”. An all-in-one solution that will emulate anything from IBM mainframes to an Apple Lisa seems attractive but will be hard to maintain.

Luckily, Altair 8800 emulators and operating systems are trivial to find on Github and other sites. SIMH should run it just fine, though I have not confirmed this personally.

Could it have been Kill the Bit (https://www.youtube.com/watch?v=ZKeiQ8e18QY)?

I do not think Kill the Bit even uses the terminal?

Maybe this one: Target (1976) - MITS Altair 8800 soft. by Altair Soft. Distribution Co.

It legit sounds fun to me as you describe it. It also sounds like a fun hobbyist coding project. Anyone here know how to code browser games and is maybe retired? heh.

If you clicked in a corner near a dot, did the dot get pushed diagonally, or was it strictly up/down left/right?

Here’s Gemini’s attempt at recreating it. I have no idea if it’s the right game, and I doubt that anything moved this fast on an Altair.

This was my prompt:

The Altair 8800 computer had a game called Target. It’s described here (Target (1976) - MITS Altair 8800 soft. by Altair Soft. Distribution Co.) and here (https://www.mobygames.com/game/111250/target/). You can probably find other descriptions in your massive memory. Can you write HTML/Javascript code to emulate it? It should be very retro, with only text characters, no fancy space ship graphics, and the keyboard should control it, not the mouse

Summary
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Target (1977) - Altair 8800 / Sol-20 Terminal Emulation</title>
    <script src="https://cdn.tailwindcss.com"></script>
    <style>
        @import url('https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;600;700&display=swap');

        body {
            background-color: #050805;
            color: #33ff33;
            font-family: 'Fira Code', monospace;
            user-select: none;
            margin: 0;
            overflow: hidden;
        }

        /* CRT Glowing Text effect */
        .crt-text {
            color: #33ff33;
            text-shadow: 0 0 2px rgba(51, 255, 51, 0.7), 0 0 8px rgba(51, 255, 51, 0.4);
        }

        .crt-amber {
            color: #ffb000;
            text-shadow: 0 0 2px rgba(255, 176, 0, 0.7), 0 0 8px rgba(255, 176, 0, 0.4);
        }

        .crt-white {
            color: #e0ffe0;
            text-shadow: 0 0 3px rgba(224, 255, 224, 0.8);
        }

        /* CRT Monitor Screen FX */
        .crt-container {
            position: relative;
            box-shadow: inset 0 0 100px rgba(0, 0, 0, 0.9), 0 0 30px rgba(51, 255, 51, 0.15);
            border: 18px solid #1a1e1a;
            border-radius: 20px;
        }

        /* Scanlines */
        .scanlines {
            position: absolute;
            top: 0; left: 0; width: 100%; height: 100%;
            background: linear-gradient(
                rgba(18, 16, 16, 0) 50%, 
                rgba(0, 0, 0, 0.35) 50%
            );
            background-size: 100% 4px;
            z-index: 20;
            pointer-events: none;
        }

        /* Subtle screen flicker */
        @keyframes flicker {
            0% { opacity: 0.98; }
            50% { opacity: 1; }
            52% { opacity: 0.96; }
            80% { opacity: 0.99; }
            100% { opacity: 0.98; }
        }

        .crt-screen {
            animation: flicker 0.15s infinite;
        }

        /* CRT Vignette Curve */
        .vignette {
            position: absolute;
            top: 0; left: 0; width: 100%; height: 100%;
            box-shadow: inset 0 0 80px rgba(0,0,0,0.8);
            pointer-events: none;
            z-index: 21;
        }

        /* Responsive Text Matrix display grid */
        #game-grid {
            font-family: 'Fira Code', 'Courier New', Courier, monospace;
            line-height: 1.15;
            letter-spacing: 0px;
            white-space: pre;
        }

        /* Blinking cursor effect */
        .blink {
            animation: blinker 1s step-end infinite;
        }
        @keyframes blinker {
            50% { opacity: 0; }
        }
    </style>
</head>
<body class="h-screen w-screen flex flex-col justify-center items-center p-2 sm:p-6 bg-black">

    <!-- Terminal Frame Outer -->
    <div class="crt-container w-full max-w-5xl h-full max-h-[850px] bg-black flex flex-col justify-between p-4 sm:p-6 relative overflow-hidden">
        
        <!-- CRT Screen Overlay Effects -->
        <div class="scanlines"></div>
        <div class="vignette"></div>

        <!-- Terminal Header / System Status -->
        <div class="crt-screen z-10 flex flex-wrap justify-between items-center border-b border-green-800/60 pb-2 mb-2 text-xs sm:text-sm crt-text">
            <div>
                <span class="font-bold text-green-400">PROCESSOR TECHNOLOGY SOL-20 / ALTAIR 8800</span>
                <span class="hidden sm:inline text-green-700"> | MEMORY: 8K STATIC RAM</span>
            </div>
            <div class="flex gap-4 items-center">
                <span id="audio-status" class="text-xs px-1.5 py-0.5 rounded border border-green-700 bg-green-950/40">SOUND: ON [M]</span>
                <span id="color-mode-status" class="text-xs px-1.5 py-0.5 rounded border border-green-700 bg-green-950/40">DISP: GREEN [C]</span>
            </div>
        </div>

        <!-- ASCII Screen Display Grid -->
        <div class="crt-screen z-10 flex-grow flex items-center justify-center overflow-hidden my-auto">
            <pre id="game-grid" class="crt-text font-bold text-center select-none text-[10px] sm:text-[13px] md:text-[15px] lg:text-[17px] leading-tight"></pre>
        </div>

        <!-- Keyboard Controls & Status Bar -->
        <div class="crt-screen z-10 border-t border-green-800/60 pt-3 mt-2 text-xs sm:text-sm crt-text flex flex-col sm:flex-row justify-between items-center gap-2">
            <div class="flex flex-wrap justify-center gap-3 text-xs sm:text-sm">
                <span><kbd class="px-1.5 py-0.5 bg-green-950 border border-green-600 rounded">A</kbd>/<kbd class="px-1.5 py-0.5 bg-green-950 border border-green-600 rounded">D</kbd> or <kbd class="px-1.5 py-0.5 bg-green-950 border border-green-600 rounded">&larr;</kbd>/<kbd class="px-1.5 py-0.5 bg-green-950 border border-green-600 rounded">&rarr;</kbd> AIM</span>
                <span><kbd class="px-1.5 py-0.5 bg-green-950 border border-green-600 rounded">SPACE</kbd> FIRE</span>
                <span><kbd class="px-1.5 py-0.5 bg-green-950 border border-green-600 rounded">P</kbd> PAUSE</span>
                <span><kbd class="px-1.5 py-0.5 bg-green-950 border border-green-600 rounded">R</kbd> RESTART</span>
            </div>
            <div class="text-xs text-green-600">
                ORIGINAL CODE: S. DOMPIER (1977)
            </div>
        </div>
    </div>

    <!-- Retro Audio Generator using Web Audio API -->
    <script>
        class RetroAudio {
            constructor() {
                this.ctx = null;
                this.enabled = true;
            }

            init() {
                if (!this.ctx) {
                    const AudioContext = window.AudioContext || window.webkitAudioContext;
                    if (AudioContext) {
                        this.ctx = new AudioContext();
                    }
                }
                if (this.ctx && this.ctx.state === 'suspended') {
                    this.ctx.resume();
                }
            }

            toggle() {
                this.enabled = !this.enabled;
                return this.enabled;
            }

            playBeep(freq = 440, type = 'square', duration = 0.05, vol = 0.1) {
                if (!this.enabled) return;
                this.init();
                if (!this.ctx) return;

                try {
                    const osc = this.ctx.createOscillator();
                    const gain = this.ctx.createGain();

                    osc.type = type;
                    osc.frequency.setValueAtTime(freq, this.ctx.currentTime);

                    gain.gain.setValueAtTime(vol, this.ctx.currentTime);
                    gain.gain.exponentialRampToValueAtTime(0.001, this.ctx.currentTime + duration);

                    osc.connect(gain);
                    gain.connect(this.ctx.destination);

                    osc.start();
                    osc.stop(this.ctx.currentTime + duration);
                } catch (e) {
                    // Audio fail-safe
                }
            }

            playFireSound() {
                if (!this.enabled) return;
                this.init();
                if (!this.ctx) return;

                try {
                    const osc = this.ctx.createOscillator();
                    const gain = this.ctx.createGain();

                    osc.type = 'sawtooth';
                    osc.frequency.setValueAtTime(600, this.ctx.currentTime);
                    osc.frequency.exponentialRampToValueAtTime(80, this.ctx.currentTime + 0.15);

                    gain.gain.setValueAtTime(0.12, this.ctx.currentTime);
                    gain.gain.linearRampToValueAtTime(0.01, this.ctx.currentTime + 0.15);

                    osc.connect(gain);
                    gain.connect(this.ctx.destination);

                    osc.start();
                    osc.stop(this.ctx.currentTime + 0.15);
                } catch(e) {}
            }

            playExplosionSound() {
                if (!this.enabled) return;
                this.init();
                if (!this.ctx) return;

                try {
                    // White noise buffer for explosion
                    const bufferSize = this.ctx.sampleRate * 0.25;
                    const buffer = this.ctx.createBuffer(1, bufferSize, this.ctx.sampleRate);
                    const output = buffer.getChannelData(0);
                    for (let i = 0; i < bufferSize; i++) {
                        output[i] = Math.random() * 2 - 1;
                    }

                    const whiteNoise = this.ctx.createBufferSource();
                    whiteNoise.buffer = buffer;

                    const filter = this.ctx.createBiquadFilter();
                    filter.type = 'lowpass';
                    filter.frequency.setValueAtTime(800, this.ctx.currentTime);
                    filter.frequency.linearRampToValueAtTime(50, this.ctx.currentTime + 0.25);

                    const gain = this.ctx.createGain();
                    gain.gain.setValueAtTime(0.2, this.ctx.currentTime);
                    gain.gain.exponentialRampToValueAtTime(0.01, this.ctx.currentTime + 0.25);

                    whiteNoise.connect(filter);
                    filter.connect(gain);
                    gain.connect(this.ctx.destination);

                    whiteNoise.start();
                    whiteNoise.stop(this.ctx.currentTime + 0.25);
                } catch(e) {}
            }

            playTargetHitBonus() {
                if (!this.enabled) return;
                let notes = [523.25, 659.25, 783.99, 1046.50];
                notes.forEach((freq, idx) => {
                    setTimeout(() => {
                        this.playBeep(freq, 'triangle', 0.08, 0.15);
                    }, idx * 60);
                });
            }
        }

        // Initialize Audio System
        const audio = new RetroAudio();

        // -------------------------------------------------------------
        // ALTAIR TARGET GAME ENGINE (ASCII Grid Matrix Emulation)
        // -------------------------------------------------------------
        const GRID_WIDTH = 64;
        const GRID_HEIGHT = 22;

        const GAME_STATE = {
            START_SCREEN: 0,
            PLAYING: 1,
            PAUSED: 2,
            GAME_OVER: 3
        };

        // Cannon Turret Angles Definition (ASCII Gun visual representations and vectors)
        const TURRET_ANGLES = [
            { name: "FAR_LEFT",   dx: -1.2, dy: -0.6, char: "\\", label: "-60°" },
            { name: "MID_LEFT",   dx: -0.7, dy: -0.8, char: "\\", label: "-35°" },
            { name: "CENTER",     dx: 0.0,  dy: -1.0, char: "|",  label: " 0°" },
            { name: "MID_RIGHT",  dx: 0.7,  dy: -0.8, char: "/",  label: "+35°" },
            { name: "FAR_RIGHT",  dx: 1.2,  dy: -0.6, char: "/",  label: "+60°" }
        ];

        // Target Types Definition
        const TARGET_TYPES = [
            { sprite: "<===>", speed: 0.45, points: 100, color: "std" },
            { sprite: "[+#+]", speed: 0.65, points: 200, color: "std" },
            { sprite: ">--->", speed: 0.85, points: 300, color: "std" },
            { sprite: "=-*-=", speed: 1.10, points: 500, color: "std" },
            { sprite: "*UFO*", speed: 1.45, points: 1000, color: "std" }
        ];

        class TargetGame {
            constructor() {
                this.state = GAME_STATE.START_SCREEN;
                this.grid = [];
                this.turretIndex = 2; // Default Center (0: -60, 1: -35, 2: 0, 3: +35, 4: +60)
                this.shotsRemaining = 20;
                this.score = 0;
                this.hits = 0;
                this.misses = 0;
                this.highScore = 0;

                this.targets = [];
                this.missiles = [];
                this.explosions = [];

                this.colorPalette = "GREEN"; // GREEN or AMBER
                this.lastTime = 0;
                this.spawnTimer = 0;

                this.initGrid();
            }

            initGrid() {
                this.grid = Array(GRID_HEIGHT).fill(0).map(() => Array(GRID_WIDTH).fill(' '));
            }

            clearGrid() {
                for (let r = 0; r < GRID_HEIGHT; r++) {
                    for (let c = 0; c < GRID_WIDTH; c++) {
                        this.grid[r][c] = ' ';
                    }
                }
            }

            startNewGame() {
                this.score = 0;
                this.shotsRemaining = 25;
                this.hits = 0;
                this.misses = 0;
                this.turretIndex = 2;
                this.targets = [];
                this.missiles = [];
                this.explosions = [];
                this.state = GAME_STATE.PLAYING;
                
                // Spawn initial target
                this.spawnTarget();
            }

            spawnTarget() {
                // Select random row between row 2 and 9
                const row = Math.floor(Math.random() * 8) + 2;
                
                // Random direction: 1 (left to right), -1 (right to left)
                const dir = Math.random() > 0.5 ? 1 : -1;
                
                // Pick random target type weighted by difficulty
                const typeIdx = Math.floor(Math.pow(Math.random(), 1.5) * TARGET_TYPES.length);
                const type = TARGET_TYPES[typeIdx];

                const startX = dir === 1 ? -type.sprite.length : GRID_WIDTH + 1;

                this.targets.push({
                    x: startX,
                    y: row,
                    dx: type.speed * dir,
                    sprite: type.sprite,
                    points: type.points,
                    width: type.sprite.length
                });
            }

            fireMissile() {
                if (this.shotsRemaining <= 0) return;

                // Max 3 active projectiles on screen at once
                if (this.missiles.length >= 3) return;

                this.shotsRemaining--;
                const turret = TURRET_ANGLES[this.turretIndex];

                // Turret muzzle position at bottom center
                const startX = Math.floor(GRID_WIDTH / 2);
                const startY = GRID_HEIGHT - 3;

                this.missiles.push({
                    x: startX,
                    y: startY,
                    dx: turret.dx,
                    dy: turret.dy,
                    char: '|'
                });

                audio.playFireSound();
            }

            rotateTurret(dir) {
                if (dir === -1 && this.turretIndex > 0) {
                    this.turretIndex--;
                    audio.playBeep(300, 'square', 0.03, 0.05);
                } else if (dir === 1 && this.turretIndex < TURRET_ANGLES.length - 1) {
                    this.turretIndex++;
                    audio.playBeep(300, 'square', 0.03, 0.05);
                }
            }

            update(deltaTime) {
                if (this.state !== GAME_STATE.PLAYING) return;

                // Spawn target timer logic
                this.spawnTimer += deltaTime;
                if (this.targets.length < 3 && (this.spawnTimer > 1.8 || this.targets.length === 0)) {
                    this.spawnTarget();
                    this.spawnTimer = 0;
                }

                // 1. Update Targets
                for (let i = this.targets.length - 1; i >= 0; i--) {
                    const t = this.targets[i];
                    t.x += t.dx;

                    // Offscreen check
                    if ((t.dx > 0 && t.x > GRID_WIDTH + 2) || (t.dx < 0 && t.x < -t.width - 2)) {
                        this.targets.splice(i, 1);
                    }
                }

                // 2. Update Missiles
                for (let i = this.missiles.length - 1; i >= 0; i--) {
                    const m = this.missiles[i];
                    m.x += m.dx;
                    m.y += m.dy;

                    // Update missile character symbol depending on angle
                    if (Math.abs(m.dx) < 0.2) m.char = '|';
                    else if (m.dx < 0) m.char = '\\';
                    else m.char = '/';

                    // Collision Detection with Targets
                    let hitDetected = false;
                    const mGridX = Math.round(m.x);
                    const mGridY = Math.round(m.y);

                    for (let j = this.targets.length - 1; j >= 0; j--) {
                        const t = this.targets[j];
                        const tGridY = Math.round(t.y);
                        const tMinX = Math.floor(t.x);
                        const tMaxX = tMinX + t.width - 1;

                        if (mGridY === tGridY && mGridX >= tMinX && mGridX <= tMaxX) {
                            // HIT!
                            hitDetected = true;
                            this.score += t.points;
                            this.hits++;

                            if (this.score > this.highScore) {
                                this.highScore = this.score;
                            }

                            // Trigger Explosion ASCII
                            this.explosions.push({
                                x: mGridX,
                                y: mGridY,
                                frame: 0,
                                maxFrames: 12,
                                points: t.points
                            });

                            audio.playExplosionSound();
                            if (t.points >= 500) {
                                audio.playTargetHitBonus();
                            }

                            // Remove Target
                            this.targets.splice(j, 1);
                            break;
                        }
                    }

                    if (hitDetected) {
                        this.missiles.splice(i, 1);
                        continue;
                    }

                    // Check bounds / Offscreen Miss
                    if (m.y < 1 || m.x < 0 || m.x >= GRID_WIDTH) {
                        this.misses++;
                        this.missiles.splice(i, 1);

                        // If out of ammo and no active projectiles left, Game Over
                        if (this.shotsRemaining === 0 && this.missiles.length === 0) {
                            setTimeout(() => { this.endGame(); }, 600);
                        }
                    }
                }

                // Check out of shots condition
                if (this.shotsRemaining === 0 && this.missiles.length === 0 && this.targets.length === 0) {
                    this.endGame();
                }

                // 3. Update Explosions
                for (let i = this.explosions.length - 1; i >= 0; i--) {
                    const ex = this.explosions[i];
                    ex.frame++;
                    if (ex.frame >= ex.maxFrames) {
                        this.explosions.splice(i, 1);
                    }
                }
            }

            endGame() {
                this.state = GAME_STATE.GAME_OVER;
                audio.playBeep(200, 'sawtooth', 0.3, 0.2);
            }

            render() {
                this.clearGrid();

                if (this.state === GAME_STATE.START_SCREEN) {
                    this.renderStartScreen();
                } else if (this.state === GAME_STATE.PLAYING || this.state === GAME_STATE.PAUSED) {
                    this.renderPlayScreen();
                } else if (this.state === GAME_STATE.GAME_OVER) {
                    this.renderGameOverScreen();
                }

                // Convert grid to ASCII String output
                const gridText = this.grid.map(row => row.join('')).join('\n');
                document.getElementById('game-grid').textContent = gridText;
            }

            writeString(row, col, str) {
                if (row < 0 || row >= GRID_HEIGHT) return;
                for (let i = 0; i < str.length; i++) {
                    const c = col + i;
                    if (c >= 0 && c < GRID_WIDTH) {
                        this.grid[row][c] = str[i];
                    }
                }
            }

            drawBox(startRow, startCol, height, width) {
                for (let r = 0; r < height; r++) {
                    for (let c = 0; c < width; c++) {
                        const currR = startRow + r;
                        const currC = startCol + c;
                        if (currR >= 0 && currR < GRID_HEIGHT && currC >= 0 && currC < GRID_WIDTH) {
                            if (r === 0 || r === height - 1) {
                                this.grid[currR][currC] = '=';
                            } else if (c === 0 || c === width - 1) {
                                this.grid[currR][currC] = '|';
                            }
                        }
                    }
                }
                // Corners
                if (startRow >= 0 && startCol >= 0) this.grid[startRow][startCol] = '+';
                if (startRow >= 0 && startCol + width - 1 < GRID_WIDTH) this.grid[startRow][startCol + width - 1] = '+';
                if (startRow + height - 1 < GRID_HEIGHT && startCol >= 0) this.grid[startRow + height - 1][startCol] = '+';
                if (startRow + height - 1 < GRID_HEIGHT && startCol + width - 1 < GRID_WIDTH) this.grid[startRow + height - 1][startCol + width - 1] = '+';
            }

            renderStartScreen() {
                // Header Banner
                this.writeString(1, 14, "====================================");
                this.writeString(2, 14, "    A L T A I R   8 8 0 0           ");
                this.writeString(3, 14, "      T A R G E T   (1 9 7 7)       ");
                this.writeString(4, 14, "====================================");

                this.writeString(6, 8, "ORIGINAL ASCII TARGET COMPUTER GAME BY STEVE DOMPIER");
                this.writeString(7, 12, "PROCESSOR TECHNOLOGY CORPORATION / MICRO-8");

                this.writeString(10, 10, "TARGET SYMBOLS & POINT VALUES:");
                this.writeString(11, 12, "<===> : 100 PTS      [+#+] : 200 PTS");
                this.writeString(12, 12, ">---> : 300 PTS      =-*-= : 500 PTS");
                this.writeString(13, 12, "*UFO* : 1000 PTS (HIGH SPEED BONUS!)");

                this.writeString(16, 12, "KEYBOARD CONTROLS:");
                this.writeString(17, 14, "[A] / [D] or LEFT/RIGHT ARROW : AIM LAUNCHER");
                this.writeString(18, 14, "[SPACEBAR]                   : FIRE MISSILE");
                this.writeString(19, 14, "[M] MUTE SOUND   |  [C] GREEN/AMBER COLOR");

                this.writeString(21, 15, "PRESS [SPACE] OR [ENTER] TO START GAME");
            }

            renderPlayScreen() {
                // Top Status / Score Header Bar
                const scoreStr = `SCORE: ${String(this.score).padStart(5, '0')}`;
                const ammoStr  = `AMMO: ${String(this.shotsRemaining).padStart(2, '0')}`;
                const angleStr = `AIM: ${TURRET_ANGLES[this.turretIndex].label}`;
                const highStr  = `HI-SCORE: ${String(this.highScore).padStart(5, '0')}`;

                this.writeString(0, 1, `${scoreStr}   ${ammoStr}   ${angleStr}   ${highStr}`);
                this.writeString(1, 0, "-".repeat(GRID_WIDTH));

                // Ground Line
                const groundRow = GRID_HEIGHT - 2;
                this.writeString(groundRow, 0, "=".repeat(GRID_WIDTH));

                // Draw Ground Launcher Base / Turret
                const centerCol = Math.floor(GRID_WIDTH / 2);
                const turretChar = TURRET_ANGLES[this.turretIndex].char;
                
                this.writeString(groundRow - 1, centerCol - 2, " [A] ");
                this.grid[groundRow - 1][centerCol] = turretChar;
                this.writeString(groundRow, centerCol - 3, "/=====\\");

                // Draw Targets
                this.targets.forEach(t => {
                    const r = Math.round(t.y);
                    const c = Math.round(t.x);
                    this.writeString(r, c, t.sprite);
                });

                // Draw Missiles
                this.missiles.forEach(m => {
                    const r = Math.round(m.y);
                    const c = Math.round(m.x);
                    if (r >= 0 && r < GRID_HEIGHT && c >= 0 && c < GRID_WIDTH) {
                        this.grid[r][c] = m.char;
                    }
                });

                // Draw Explosions
                this.explosions.forEach(ex => {
                    const r = ex.y;
                    const c = ex.x;
                    const stage = Math.floor(ex.frame / 3);

                    let boomSprite = "***";
                    if (stage === 0) boomSprite = " * ";
                    else if (stage === 1) boomSprite = "#%#";
                    else if (stage === 2) boomSprite = `+${ex.points}+`;
                    else boomSprite = ". .";

                    this.writeString(r, c - Math.floor(boomSprite.length / 2), boomSprite);
                });

                // Pause Indicator
                if (this.state === GAME_STATE.PAUSED) {
                    this.drawBox(8, 20, 5, 24);
                    this.writeString(10, 24, "SYSTEM PAUSED");
                }
            }

            renderGameOverScreen() {
                // Render ground/game background behind overlay
                this.renderPlayScreen();

                // Draw Game Over Dialog Overlay Box
                const boxWidth = 44;
                const boxHeight = 11;
                const startR = 4;
                const startC = Math.floor((GRID_WIDTH - boxWidth) / 2);

                this.drawBox(startR, startC, boxHeight, boxWidth);

                const accuracy = (this.hits + this.misses) > 0 
                    ? Math.round((this.hits / (this.hits + this.misses)) * 100) 
                    : 0;

                this.writeString(startR + 2, startC + 14, "G A M E   O V E R");
                this.writeString(startR + 3, startC + 10, "------------------------");
                this.writeString(startR + 4, startC + 8, `FINAL SCORE   : ${String(this.score).padStart(6, ' ')}`);
                this.writeString(startR + 5, startC + 8, `TARGETS HIT   : ${String(this.hits).padStart(6, ' ')}`);
                this.writeString(startR + 6, startC + 8, `ACCURACY      : ${String(accuracy).padStart(5, ' ')}%`);
                this.writeString(startR + 7, startC + 8, `HIGH SCORE    : ${String(this.highScore).padStart(6, ' ')}`);
                this.writeString(startR + 9, startC + 6, "PRESS [R] OR [SPACE] TO RESTART");
            }
        }

        // Initialize Engine
        const game = new TargetGame();

        // Keyboard Event Handlers
        window.addEventListener('keydown', (e) => {
            // Prevent default arrow key scrolling
            if (['ArrowLeft', 'ArrowRight', 'Space', 'KeyA', 'KeyD'].includes(e.code)) {
                e.preventDefault();
            }

            // Audio Activation
            audio.init();

            if (game.state === GAME_STATE.START_SCREEN) {
                if (e.code === 'Space' || e.code === 'Enter') {
                    game.startNewGame();
                }
            } else if (game.state === GAME_STATE.PLAYING) {
                if (e.code === 'ArrowLeft' || e.code === 'KeyA') {
                    game.rotateTurret(-1);
                } else if (e.code === 'ArrowRight' || e.code === 'KeyD') {
                    game.rotateTurret(1);
                } else if (e.code === 'Space') {
                    game.fireMissile();
                } else if (e.code === 'KeyP') {
                    game.state = GAME_STATE.PAUSED;
                } else if (e.code === 'KeyR') {
                    game.startNewGame();
                }
            } else if (game.state === GAME_STATE.PAUSED) {
                if (e.code === 'KeyP' || e.code === 'Space') {
                    game.state = GAME_STATE.PLAYING;
                }
            } else if (game.state === GAME_STATE.GAME_OVER) {
                if (e.code === 'KeyR' || e.code === 'Space' || e.code === 'Enter') {
                    game.startNewGame();
                }
            }

            // Global Keybinds
            if (e.code === 'KeyM') {
                const isAudioOn = audio.toggle();
                const statusEl = document.getElementById('audio-status');
                statusEl.textContent = `SOUND: ${isAudioOn ? 'ON' : 'OFF'} [M]`;
            }

            // Display Color Palette Switcher (Green Phosphor vs Amber Phosphor)
            if (e.code === 'KeyC') {
                const gridEl = document.getElementById('game-grid');
                const modeEl = document.getElementById('color-mode-status');
                if (gridEl.classList.contains('crt-text')) {
                    gridEl.classList.remove('crt-text');
                    gridEl.classList.add('crt-amber');
                    modeEl.textContent = "DISP: AMBER [C]";
                } else {
                    gridEl.classList.remove('crt-amber');
                    gridEl.classList.add('crt-text');
                    modeEl.textContent = "DISP: GREEN [C]";
                }
            }
        });

        // Main Animation & Render Loop
        let lastTime = performance.now();
        function gameLoop(currentTime) {
            const deltaTime = (currentTime - lastTime) / 1000;
            lastTime = currentTime;

            game.update(deltaTime);
            game.render();

            requestAnimationFrame(gameLoop);
        }

        // Start Loop on Window Load
        window.onload = function() {
            requestAnimationFrame(gameLoop);
        };
    </script>
</body>
</html>

Just copy the HTML into a file with an HTML extension and it should open up in a browser. Feel free to plug it into your own LLM and tell it to make whatever changes.

Correct, I meant “anything DOS or early Windows”

Was there a DOS port, though?? It does not seem like it, but who knows?

That is super cool that that works. Definitely a different game than the one OP describes, though.