March 27, 2017 23:09:10
Sometimes the best medicine is to stop taking something.
Recent updates:
Satellite calculator
(initial release)
(improved support for multi-chunk patches) library
(rational type, CRCs, etc)
WebDAV server
(feature complete, documentation, package)
(This American Life downloader) library
(arbitrary-precision integer type, etc)
(quick intercepts, time advancement)
(initial release) library
(high-precision floating point type)
Code Home // Mercurial Access

 .:  My code
On this page are some of the personal projects I've undertaken, in a very roughly reverse chronological order. Most are old and don't reflect my current style and ability. Also, this actually represents only about half of my personal projects; the rest were lost in a hard-drive crash several years ago. I've since become a backup evangelist.
  • Satellite Network Calculator, Language: Javascript, License: None (public domain)
    This is an interactive calculator that helps design equatorial satellite communication networks in Kerbal Space Program. It was designed for use with the RemoteTech mod, but may be useful with the communication network support added to KSP version 1.2 as well.
  • taldl, Language: C#, License: None (public domain)
    This is a simple program I whipped up one night to download episodes of This American Life from the internet. (The website lets you listen online for free but wants you to pay a dollar per episode to download them.)
  • ExePatch, Language: C#, Licence: GPL v2
    ExePatch is an assembly IDE designed to simplify the development of binary patches to executables, such as when creating code mods for video games, although it should work for many kinds of executable patching needs.
  • WebDAV server, Language: C#, Licence: GPL v2
    This library implements a flexible, extensible, and quite standards-compliant WebDAV server built on ASP.NET. The WebDAV server can serve any type of hierarchical data, not only files. It supports transparent compression, partial transfers, partial updates, locking, editing, dead properties, strong typing of WebDAV properties, request preconditions, and other features. Setting up a simple WebDAV server to serve some files only requires adding some lines to your web.config file; no code needs to be written. If you want to serve another type of data over WebDAV, it's fairly easy to implement new service providers.
  • Capitalism 2 Mod Kit, Language: C#, Size: 218k, License: None (public domain)
    This is a mod kit that allows you to edit the game database for Capitalism 2 using a spreadsheet, and to edit many of the game's graphics. Sad to say, editing the database requires an installation of Microsoft Excel 2007 or later, but it's very convenient. (Excel isn't required to edit game images.) It's based on my efforts to reverse engineer the game, described here. I used the mod kit to create a mod that rebalances the game.
  • Dangerous Waters Mod Utilities, Language: C#, Size: 79k, License: GPL v2
    This is a collection of mod utilities for the game Dangerous Waters. Currently, it only includes one utility, which allows you to manage the .grp/.ndx archive files used by the game to extract and alter game assets. It also includes a list of all the command-line arguments recognized by the game, including ones for debugging. Some details about the file formats and my reverse engineering effort can be found here.
  • pad, Language: C#, Size: 69k, License: GPL v2
    This is a simple console application to perform high-speed encryption and decryption of files. It's named "pad" because it was originally designed for one-time pads, but that's no longer supported. It's intended to be used to encrypt and decrypt large files and/or a large number of files quickly. It can encrypt entire directory trees (or subsets thereof), and a novel feature is that it can encrypt and decrypt not only file contents but also file and directory names. This makes it useful for quickly obscuring the contents of a large directory tree. Files are encrypted and decrypted in place with only very small changes to the file size, so in the great majority of cases, no additional space must be allocated on the filesystem. A previous version of this program didn't change the file size at all, but that made it impossible to use per-file IVs or to detect incorrect decryption keys or passwords. The current version is much improved in those respects. A program like GPG would store the ciphertext in a separate file, leaving the plaintext allocated on disk and plainly visible to simple forensics tools if it was not securely deleted, and taking up substantial disk space when dealing with large files. GPG would also be slower. That said, pad is not intended to be a replacement for a sophisticated encryption program like GPG.
  • Maneubo, Language: C#, Size: 190k, License: GPL v2
    Maneubo is a program that was originally intended to provide a kind of virtual maneuvering board. A maneuvering board is a specialized chart used to plot the motions of craft, compute intercept and avoidance courses, etc. Maneubo does not provide a true maneuvering board, and in fact I consider them to be more or less obsolete, but Maneubo dispenses with the chart and automates the calculations, allowing you to do the same kinds of things much more conveniently. It is intended to be used along with simulations (e.g. submarine simulations) as an aid, but as it contains the basics of a general vector-based plotting tool, it might be useful for other things.
  • du, Language: C#, Size: 8k, License: None (public domain)
    This is a very simple console application I wrote to help me free up some disk space. It scans a directory and prints the items that are taking the most space.
  • IrcLib, Language: C#, License: GPL v2
    This is a simple and easy-to-use IRC client library. It was created as part of the latest version of HalBot, but can be used for other things.
  • Battery Charger, Language: C and assembly, License: GPL v2
    I created a NiMH battery charger, and this is the control software for it.
  • Picture Sorter, Language: C#, License: GPL v2
    This is a program that makes it easier to rename, rotate, and resize large numbers of pictures, generate thumbnails for them, and convert their image formats. It supercedes the Nails program I developed.
  • Terrain Generator, Size: 184k, Language: C#, License: GPL v2
    This is a prototype terrain generator that I was writing for use in a clone of the game Dwarf Fortress. I didn't finish the game, but the terrain generator was pretty nifty. It's a fractal terrain generator based on coherent noise. It simulates the effects of wind (including rain shadows) as well as thermal and hydraulic erosion. See the source code to find all the keyboard commands that control it.
  • GPG Desktop, Language: C#, License: GPL v2
    This is an attempt to make encryption simpler to use for the average person by providing a front end to the GNU Privacy Guard. The front end is built on top of my OpenPGP security and UI libraries. It provides a powerful key manager, and wizards to walk the user through basic tasks, such as encryption, signing, decryption, and signature verification.
  • libraries, Language: C#, License: GPL v2
    A bunch of things that I've written and found useful. This is a relatively high quality set of libraries, with good documentation, comments, and unit tests. It covers collections, IO, artificial intelligence, mathematics, UI, security, and transactions. Some parts are works in progress. I add things to this every so often, usually after I've written something for the second or third time and decide to generalize it so I don't have to write it ever again.
  • Nails, Size: 22k, Language: C#, License: GPL v2
    I used to have a bash shell script to create thumbnails using ImageMagick, but I lost it. Since then, I've been too lazy to do much with pictures because making thumbnails out of them is such a pain. Finally I whipped together this simple program to automatically create thumbnails from a bunch of image files. It supports a couple different resize modes and a somewhat flexible thumbnail naming scheme, and it's simple (if unintuitive) to use. This program has been superceded by the Picture Sorter program I wrote.
  • Gene Hackman, Language: C#, License: GPL v2
    Originally called "Bugger", Gene Hackman is a framework for genetic programming. A novel feature is that it supports an ongoing tournament mode, where programs compete in real time rather than well-defined and distinct generations. This lends itself to certain problems well, such as those where programs can interact with each other. It also supports parallelizing the simulation across multiple threads and compiling it to native code, among other things. I've applied it to the problem of creatures learning to find food and survive in a simple world, and that application is included in the source. It presents the world and its inhabitants in a graphical manner, so you can watch them evolve. It wasn't meant for release, so some of the application code is messy, but the framework itself is pretty good.
  • Sudoku solver, Size: 10k, Language: C#, License: None (public domain)
    Although the game Sudoku is all the rage, I don't like to play it. I don't like to play any game that I feel can be easily automated -- I'd rather spend the time writing a program to automate it. So here it is, a program to solve Sudoku puzzles.
  • C# enscript state file
    If you use GNU enscript to do syntax highlighting, you might be interested in my state file for C# (which lets enscript highlight C# files). I made this because I wanted to have C# syntax highlighting on my Subversion server. It's not perfect, but it does the basics.
  • Flatarity, Size: 442k, Language: C#, License: GPL v2
    Flatarity is a clone of Planarity, with some added features like selecting multiple vertices, rotating and flipping them, etc. The latest source is available here. I whipped this up in few hours while at work, so the code quality isn't that great.
  • Jappy, Language: C#, License: GPL v2
    Jappy is a Japanese dictionary program I wrote for myself. I have a whole laundry list of features I mean to implement but probably never well, but it's already pretty useful. It has word lookup, text translation help, example sentence search, and study helpers. Plus, you can easily jump between different parts of the program -- highlight some text and right-click to search on it. Or click to translate Japanese example sentences. Or click a headword to see example sentences containing it, etc.
  • RotationalForce, Language: C#, License: GPL v2
    The Rotational Force Engine is a vector-based 2D game engine I was working on, along with an editor for it. It's actually pretty fancy, as far as it got anyway. It supports splines, stroking, dynamic level of detail, mounting and linking objects, nifty object tracking and camera animation, and, well, lots of features. As usual, though, I never finished it. But you can check out some screenshots of the editor.
  • WebCrawl, Language: C#, License: GPL v2
    WebCrawl is a web site spiderer I wrote after being frustrated by httrack, which is supposed to be the best. Httrack was taking way too much CPU time in the GUI mode, didn't provide good enough feedback in the console mode, and didn't provide enough control overall. So I wrote a web crawler backend and a console frontend for it. It can be used much more easily than httrack. It has a number of features that httrack doesn't, such as rewriting URLs and page content on the fly with regular expressions or arbitrary processing code, which enables a few interesting and important scenarios. I use it to mirror sites for offline reading, mainly so that I can ensure that I still have a copy even if the site gets taken down. New version (May 3rd, 2008) adds a graphical frontend.
  • BuLang, Size: 33k, Language: C#, License: GPL v2
    BuLang is a relatively simple programming language that I whipped up over the course of a few hours to help my girlfriend automate some of her finance homework. I heard that she was performing bond valuation calculations by hand, which requires hitting hundreds of buttons on the calculator to get the result. And of course, one mispress would throw the answer off. It sounded like such a huge pain in the ass that I just had to do something! The language has specialized constructs like 'sigma', which computes the summation of a sequence (a common operation in finance). The program provides a text editor and a console window. In the zip file is the bond valuation function I wrote as an example. Although it was thrown together very quickly, it's actually pretty clean code, and a potentially useful starting point for the creation of other little languages.
  • Space Winds, Language: C#, License: GPL v2
    This was going to be a clone of the old game Solar Winds, but with updated graphics. I learned some rudimentary 3D modeling for this game, and created a couple ships. The code lets you fly one of the ships while being attacked by an AI flying the other ship. The part I like best is that the weapons on the ships are separate entities and can rotate independently. It just looked cool. :-) Alas, I never finished it.
  • Halbot, Language: C#, License: GPL v2
    This is a rewrite of Halbot in C#, using my own Markov model implementation. New version (July 29th, 2010) is completely rewritten, supports RSS feeds, tracking conversations, and smarter analysis, and contains much cleaner code.
  • NetLisp, Language: C#, License: GPL v2
    NetLisp is the technological successor to Boa. Like Boa, NetLisp works both in an interpreted and compiled mode (and unlike Boa, the interpretation support is complete), and targets the .NET framework. However, NetLisp is modeled after Scheme and other LISP languages. It includes three interfaces -- an embeddable .DLL, a command-line interactive shell/compiler, and a rudimentary IDE.
  • Boa, Language: C#, License: GPL v2
    Boa is a language similar to Python. It's both interpreted and compiled, targetting the .NET framework. It includes three interfaces -- an embeddable .DLL, a command-line interactive shell/compiler, and a rudimentary IDE.
  • Markov, Size: 29k, Language: C#, License: GPL v2
    A man from Taiwan recently emailed me asking about HalBot. He wanted to study how it works. Since it's based on MegaHal by Jason Hutchens, it's pretty hard to understand, since that's how Jason likes his code (you know, job security and all). So I created a very simple Markov chain implementation. It can use an arbitrary model order, so you can tweak that and see the effect it has on the output. It's not meant as a replacement for MegaHal, since it doesn't attempt to make conversation. And it isn't really meant for general consumption, but I figured I'd share it anyway. Since it's written it C#, it requires the .NET Framework in order to run. Incidentally, the Megahal source has improved quite a bit since I created HalBot. It's been taken over by somebody who's in the process of cleaning it up and commenting it.
  • Smarm, Language: C#, License: GPL v2
    This program is a level editor for the game Swarm. Swarm is being developed by Jim Crawford. The primary impetus behind the editor was that the levels, bitmap in nature, are too large to be edited in a bitmap editor such as Photoshop (a single level may be easily be 600 megabytes uncompressed). Thus, the editor presents what appears to be a single, huge, layered image but which is actually being streamed from thousands of smaller images in a sparse matrix. The smaller images themselves are stored using a virtual filesystem which resides inside a single file, because having 20,000 files comprise a single level is just plain unprofessional, and an awful waste of space, too, when you take cluster size into account. In addition, the level is drawn at 16x normal size and scaled down for the actual game. This provides a nice antialiased look to the artwork. The editor allows zooming out up to 1/256th the actual size, because the levels can get really big. The editor also includes object and polygon editors and a pretty spiffy UI. The code itself is pretty messy, though, as it's a work in progress and was put together fairly hastily. This project uses the GameLib library.
  • Triangle Chase .NET rewrite, Language: C#, License: GPL v2
    Yet another game that'll probably never get finished. This is a rewrite of Triangle Chase using C# and the new GameLib. It's basically the same game, updated slightly (24-bit graphics instead of 8-bit, for instance). The majority of its reason for existence is merely to test the new GameLib. The code is a tad crappy because it was started as an almost direct port of the C++ version, including all the old design flaws. I've since fixed a few, but many remain.
  • Chrono .NET rewrite, Language: C#, License: GPL v2
    This is a rewrite of Chrono, a Roguelike engine/game. The design is much cleaner than the old one, and should be far more easily extensible. The game is written in pure, portable C# and contains all code except the low-level input/output, which is encapsulated within a single class. Multiple input/output classes can be created for different front-ends. Note that some parts of the code have not been fully thought out, yet, so bits of the design are sure to seem peculiar.
  • .NET port of AU.Common library, Language: C#, License: LGPL v2.1
    This is a port of the AU.Common ActiveX library to the .NET framework. It doesn't support the exact same API, but the interface is very similar in functionality. It is designed to aid in the creation of .NET components and ASP.NET applications, and like AU.Common, it is a work in progress. The source code seems to have been lost.
  • Dictionary server library and client, Size: 10k, Language: Python, License: GPL v2
    This small project is my first Python program. It consists of a Python module that implements the dictionary protocol described in RFC 2229, and a client program that uses the module. Errors should be caught by the program, but are not handled elegantly. As it's my first Python program, it was meant to be a learning experience, not an exercise in good coding style, and it shows. The application allows you to get definitions of words from various online dictionaries. As an added bonus, if you invoke the program as "thes", it will connect to server with a thesaurus by default. You can do that by symlinking "thes" to "dict". (Invoking it as "thes" just modifies some defaults. You could do the same thing on the command line or with an alias/script). The default server selections should be fine, but see for a list of additional servers.
  • GameLib, Language: C#, License: GPL v2
    This is actually the third and a half version of my "game" library. The first version was intended to be a library that allowed games to be written portably for DOS or Windows. The second iteration dropped DOS support and focused on providing a lot of functionality for multimedia/graphical applications running under Windows, including streaming playback of many video and audio formats, scripting support, and other fancy things. The next version departed from the game genre and aimed to abstract away the operating system, allowing programs to be written portably. I got it compiling under Windows and Linux and had plans for other unixes, including Mac OS X to be supported as well. The game-specific parts weren't done, but the OS abstraction was working and very useful. Eventually, though, I realized that with mono coming along so nicely, I might as well build this atop the .NET framework, which would have the added benefit of being language-agnostic and not tying any potential users to C++ as well as reducing the amount of work I would have to do.
  • ActiveX library to aid in ASP and COM development, Version: release 4, Language: MSVC++ 7 ATL, License: LGPL v2.1
    This ActiveX library is a set of tools to aid in the creation of ASP pages and other COM objects. It comes from years of experience working with ASP, but is not quite complete. As of release 4, the library also includes a number of server-side and client-side javascript libraries. I encourage use, testing, and feedback. I plan to finish this if work permits. Due to numerous limitations in the compilers that come with Microsoft Visual Studio 6.x, this code only works with the updated compilers from MSVC++ 7.0 (.NET). These can be downloaded for free from Microsoft. It also requires the ATL library that comes with MSVC 7. You can use the Code Documentation Helper to generate documentation for this library.
  • Statistics-based Spam Filtering, Version: 0.87 alpha, Size: 21k, Language: Emacs Lisp, License: GPL v2
    For all of you who are afflicted by spam, run VM for Emacs, and don't have a large collection of emails to run through one of those other spam filters, you might consider checking out my implementation of the basic ideas present in the article "A Plan for Spam" by Paul Graham. My implementation is given as a patch to the VM 7.17 source code, but I also have patches for older versions: VM-7.14 and VM-7.07. After training it on a couple weeks' worth of email, it caught about 100% of my spam with no false positives! Note: I now use Bogofilter, with some custom LISP code to interface it with VM. If you'd like that code, let me know.
  • Code Documentation Helper, Version: 0.91 beta, Size: 13k, Language: Perl, License: GPL v2
    This simple tool aids in the documentation of code by allowing you to specify the documentation for functions, variables, etc. inline as comments. It can then scan the source tree (or whatever files you tell it to) and generate HTML documentation. Speaking of documentation, I'll have to write some so you can figure out how to use it :-) It's not nearly as intelligent as the other tools out there, but it fits my needs better than most of them, and anyway it was written before they were. Note: For .NET code, I now use the built-in XML documentation in conjunction with NDoc. For other types of source code, I've heard that Doxygen is pretty good.
  • My Emacs Customizations, Size: 23k, Language: Emacs Lisp, License: GPL v2
    While Emacs may be the one true editor and scientifically proven to be the bestest editor ever, most of its greatness comes from its extensibility. So, I've hacked some extra stuff into it, like shift-selection, alt switching, some kill safety, better (for my style) auto-indentation mode for C/C++ modes, better (imo, again) indentation functions, more intelligent movement/editing primitives, some new key bindings, and a bunch of other stuff. This is in flux as I add new features and tweak/fix existing ones. This is my default.el file.
  • HalBot, Size: 72k, Language: C++
    I based this on MegaHal by Jason Hutchens. It's essentially a chat bot that goes onto IRC (a chat network) and engages in conversation. It can be trained however you wish, and since it doesn't use any fixed rules, is capable of learning any language... including non-spoken ones. Sometimes it's pretty damned funny to watch people attempt to converse with it. Usually that's because it eventually offends them terribly. This wasn't meant to be used by anyone but me, but has a fairly decent interface, if you don't mind text mode. HalBot has been since rewritten in C#.
  • Dvorakish layout, Size: 27k, Languages: x86 assembly and C, License: None (public domain)
    This is a modified keyboard layout, based on Dvorak, which I think is superior for people who type more punctuation characters than most. I actually said it was "optimized for coding" when I finished it, but I have no proof to support that claim, and it's really only optimized for the languages I code in, namely C/C++. Basically, it's good for languages that have lots of punctuation, and also English text, of course. It's implemented as a TSR for DOS, a .KBD file for Windows 9x, a .DLL for Windows NT, and various files for *nix loadkeys, loadkmap, and the X key mapper. New version (June 8th, 2003) updates the xmodmap version to add all the international keys and fix the bug where under many window managers, the special X key combinations would fail to work. New version (January 19th, 2006) adds a DLL for 64-bit Windows NT, cleaner installation for Windows NT (no dealing with Windows File Protection), and the source code for the 32/64 bit NT DLLs. Also, the size of the NT DLL has been cut down to 1/4th its previous size. New version (July 24th, 2008) adds another keyboard layout, which is the same basic Dvorakish layout modified for typing Estonian text. New version (April 11th, 2012) updates the xmodmap format to work better with modern X windowing systems.
  • 6502 CPU Debugger, Size: 67k, Language: C++, MFC, License: GPL v2
    6502dbg - A debugger for 6502 assembly code. My first (and so far, last) attempt at writing a debugger. It worked fairly well at the time, but seems to have rotted a bit. There were actually two incarnations of this project... one in pure C using the Win32 API, and the other in C++, using the MFC (my first MFC project). I wrote it so a friend could debug some 6502 code (actually music code for the NES), but just about when this was getting useful, he fixed the bug and then lost interest, so this was no longer needed.
  • FastLoot, Language: C++ COM
    I'm VERY happy with this. Back when I played UO (Ultima Online), which is to say back when it was actually a good game and not the piece of crap that it is now, I wrote this program that allowed me to make as much gold in an hour as I normally did in several days of hunting. Basically, I got all the loot from all monsters killed in my vicinity, as well as all the good stuff that happened to be on the ground. It was also nice for the randomly spawning regs that few people took the time to pick up. The encryption algorithm and the packets have changed since this was written, so it won't work anymore, but will still live on in memory. Ahhh... those were the days...
  • Third, Size: 18k, Language: C, License: None (public domain)
    A compiler for a language of my own design, named "Third". It's difficult to code in, but also pretty fun, much like Brainfuck, but without quite so much masochism involved. Actually it's not much like Brainfuck at all, since Brainfuck was designed to be simple - exceedingly simple, as a language that is. Third supports lots of operations, but they're all one character, so you can make some really compact code. It supports named functions and variables too, as well as strings. I remember I wrote a Brainfuck interpreter in Third, and then ran a Brainfuck interpreter written in Brainfuck. It was wild. Unfortunately, I tried to improve the compiler a year later without first making a backup, and broke it. By the way, this is not representative of good compiler design by any stretch (or language design, for that matter), but, hey, it works (or, worked) and was pretty cool back when I wrote it.
  • Regexp Matcher, Size:2k, Language: C++, License: None (public domain)
    This is a simple regular expression matcher. I just coded it so I could say that I can do it. It doesn't accept standard regexp syntax, mostly because that would require writing a recursive parser. And, it could be easily extended to support more regexp constructs (like {} and []), but I didn't implement very many because that's not the part I was interested in.
  • Eclair, Size: 120k, Language: C++, GameLib, License: None (public domain)
    Eclair is an emulator for a console that never really existed. It's actually really neat. The console had a fast Z80 processor, supported a 256 color paletted mode (this caused much arguing), sound, and raster effects. Can't forget those! And other stuff too, of course (input devices, etc).
  • GuiLib, Language: C++
    GuiLib is a Windowing API, written to run under... uhh... Windows. It was my attempt at creating a neat object oriented model, sort of like MFC, but less complicated. It was indeed simple to use, but quite nonpowerful. Or, rather, things got ugly when you decided to do anything outside the design boundaries, which were rather limited.
  • Minesweeper, Language: C++
    The classic game, written with GuiLib, which means the GUI sucks. It has a "hint" button, though, which doesn't actually give a hint, but instead attempts to solve the puzzle programmatically.
  • Ronx, Size: 102k, Language: C++, GameLib, License: None (public domain)
    Ronx is a graphical dungeon crawl done with vector graphics that I put a ton of work into, but never finished... like everything else. The code is not too bad, though.
  • MudTerm, Size: 44k, Language: C++, MFC, License: None (public domain)
    MudTerm is a MUD client, written when I played MUDs. Supports color and all that and is actually pretty nice, but the feature that was going to set it apart was the fact that it would automatically map the world for you. I haven't seen any that do that well. But then I realized it would be difficult to automatically detect the method of changing world areas for all MUDs, so I stopped "temporarily" to develop a scripting language. I never finished the scripting language, due to work taking all my time, so I never finished this, either. In retrospect, I should have embedded Perl or something. The code seems to have rotted a bit.
  • GSL (General Scripting Language), Language: C++
    GSL is the scripting language I was developing for MudTerm. It's similar to javascript but without a lot of the inconsistencies and nonintuitiveness, and with better support for objects. It could actually compile various scripting languages into a common language runtime, and then interpret the runtime.. and you could expose objects to the script and vice versa. Or, that's what it would have done if I had finished it. I got the parser generator, the parser, the lexer, and the assembler/disassembler done. Then I got in trouble for dumping too much time into it, and had to stop to catch up on all the work I hadn't done. I haven't really touched it since, and the code for the parser is pretty icky.
  • do, Size: 9k, Language: C, License: None (public domain)
    A damn useful utility that I never use anymore. Essentially, it performs an operation on a bunch of files/directories, etc. It's good for programs that don't accept wildcards. If you've needed something like this, you probabably know what I mean. Actually, it's similar in spirit to xargs but not quite the same (and it's for Windows).
  • Triangle Chase, Size: 55k, Language: C++, GameLib, License: GPL v2
    Triangle Chase is a damn fun game based on Rocket Chase. It was written with fairly nice (or so I thought at the time) object oriented code. Unfortunately, the network paradigm had too many lag optimizations that ended up making the network play frustrating. Still fun, though, and the closest I've come to a completed game (sadly).
  • Artificial Intelligence, Language: C++, GameLib
    General AI stuff, mostly using genetic algorithms, but also one using a rudimentary neural network. I intended to write a cool genetic programming program, but didn't have time. AI is cool stuff.
  • AdamOS, Size: 38k, Language: x86 assembly, License: None (public domain)
    AdamOS. It has a pretentious name, but that should be allowed, given that it's an operating system written in 100% assembly. It was coming along quite nicely, until I accidentally restored a backup instead of creating one, undoing countless hours of work. (I was just getting process support implemented.) I exclaimed something vulgar, and haven't worked on it since. This is a very old project, written while 16-bit real mode operating systems were still in common use. Today, such an operating system would be laughable.
  • Boids, Size: 5k, Language: C++, GameLib, License: None (public domain)
    Boids is a little program I started whipping up. It basically uses mathematical formulas to give motion to little creatures (colored triangles, actually). The formulas correspond to actions, like "seek", "arrive", "flee", etc. It's a neat way to program movement. The code isn't very clean, though, because I just whipped it up in about 20 minutes on a whim.
  • BoloBrain, Language: C++, GameLib
    A brain (AI) for a nice Windows clone of the famous Mac game, Bolo.
  • bump, Size: 7.7k, Language: x86 asm, C, OLD GameLib, License: None (public domain)
    bump implements software bump mapping and was written long before most people had even heard of the term. You could load any 2D image and it would attempt to create a height map (or you could supply one). Then, you could move the light source with the mouse. It looked pretty damn cool and with a good height map, it was awesome for making 2D images seem 3D.
  • roto, Size: 3k, Language: C, OLD GameLib, License: None (public domain)
    roto is a crazy warped rotozoomer. When set to music, it's pretty damn groovy.
  • Chrono, Size: 31k, Language: C++, GameLib, License: GPL v2
    A roguelike (like nethack), or rather, a roguelike engine. It's in text mode, as most roguelikes are. I was too lazy to write good visibility code (instead I wrote short, simple visibility code), and quit when I actually needed to come up with content.
  • TabComp, Size: 12k, Language: x86 assembly, License: None (public domain)
    TabComp is a file/directory completion TSR for DOS, written in assembly. I eventually discovered that the NT command prompt has this built-in (disabled by default, though), so I never finished this.
  • TelnetSvr, Language: C++
    TelnetSvr is a generic text-based server that supports plugins. Basically, you just handle the text, and TelnetSvr takes care of the network stuff. I began writing this for a friend who didn't want to deal with network code, but wanted to have some kind of text server for something or other. He stopped working on whatever it was, so I stopped working on this.
  • Zirc, Language: C++, MFC
    Zirc is chat client designed to make the writers of all other chat clients give up and die. Essentially it was a fully scriptable (using GSL, above) chat client that supported IRC, ICQ, AIM, MSN, and all the other chatting protocols. Or it would have been, had I finished it. I found out that somebody else was already way ahead of me with the protocol support, even though their actual client really sucked, so I lost motivation.
  • ZWorldZ, Language: C++, GameLib
    ZWorldZ is an online, massively multiplayer game. How many times have you heard that before? Well, this was going to be a really awesome one -- one that combined all the greatness of the UO (back when it WAS great) with some of my own ideas, but I never finished it. I got the rendering engine done, and that was about it. Nice code, though, or so I thought at the time.
  • Quake Golf, Size: 532k, Language: Quake C, License: None (public domain)
    This was an addon to Quake that implemented golf. The golf "ball" was a bloody, hydrophobic head that was still alive and liked to bite. Somehow it could jump around and scream too if it got too scared. You had to move it around with your weapons (or your hands if you didn't mind the biting) in an attempt to be the first person to knock it through the goal. And you could shoot it out of other people's hands (or just kill them), of course. The addon also implemented other things, like objects travelling through teleporters, so if you're just about to kill a guy and he jumps through a teleporter, just fire a rocket right on through! ;-) He'll never expect that to teleport in right behind him. Ahhh... this was a really fun mod. Unfortunately, the file I have available for download is a very old version. The latest version (which had many bugfixes and some other improvements) has been lost.
Copyright 2003-2016 Adam Milazzo. Verbatim copying and redistribution of this entire page are permitted without royalty in any medium provided this notice is preserved.