MS-DOS VGA Arena Shooter Game

A Smash TV/Robotron-like game to help me learn a whole bunch of things about game programming, DOS & PC programming, x86 assembler & C, and VGA graphics!

Play!

The latest build of the game is under Releases. Send any feedback you wish -- it's appreciated! -- but I really don't know when I'll get back to working on this.

Setup

Builds are done on a host Linux system with Open Watcom 2.0 installed to a local directory. On my machine, that's ~/Applications/open-watcom-v2. Tests and game are run in DOSBox-X.

Clone and build Open Watcom 2 for DOS cross-compilation

You'll need to build Open Watcom 2 from source to get DOS compilation on Linux. Follow the directions on their GitHub wiki.

You may need DOSBox installed for the Open Watcom 2 build.

Modify setup.sh to use your local Open Watcom install

Changing the path of export WATCOM should be enough

Install Ruby and the RMagick gem

The spritesheet builder uses Ruby and RMagick to produce the x86 assembler spritesheets from spritesheet.bmp.

Install DOSBox-X

I used the Flatpak version and created a wrapper script in my PATH:

#!/bin/sh

flatpak run com.dosbox_x.DOSBox-X "$@"

Try building the game & tests

bin/game builds and runs game.exe and bin/test builds and runs the unit tests.

What's in here?

System access code

Everything in the system folder is about directly accessing the PC hardware:

• keyboard.c accepts keyboard input using a keyboard interrupt.
• mouse_io.c accepts mouse input.
• pc_stuff.c does various PC things with interrupts.
• vga.c accesses the VGA card and has drawing routines built for 32-bit protected mode code and using the 320x200x256 chained VGA mode (mode 10h).

Unit tests

I'm using the CuTest library to write basic unit tests for the game. I wanted to try out C unit testing and see what libraries could work on retro machines, and CuTest fit the bill. The tests run directly in DOS.

Compiled sprites

I automated the pipeline to building compiled sprites from a bitmap file. Originally, I was doing memory copies from that bitmap file, and no matter how much I optimized them, they were slow slow slow. Having Ruby build the sprites as a series of mov instructions sped up the game immensely.

Inline assembler

There's some non-trivial inline assembler in system/vga.c for drawing font glyhps. https://github.com/dhepper/font8x8 is the source of the font. I probably could have gotten the performance fast enough in pure C, but I really wanted to try some inline assembler.

Bitmap loading code

Before switching to compiled sprites, I wrote code to load BMP files to a memory location of your choosing, as well as to extract the palette for feeding to the VGA card.

Open Watcom wmake Makefiles

The Makefiles are not sophisticated, but it took me quite a while to research Open Watcom's slightly different syntax for Makefiles. The GNU make docs didn't help too much.

License

MIT License on the code. If you use any code verbatim, or do anything else with this, let me know!

CuTest has its own license.

Any art that's not the spritesheet is (C) John Bintz, all rights reserved. That should only be the chicken.bmp file that's used as an example for bitmap loading code.