Everything on this page was written by me. I am posting them here in
the hopes that they might be useful to someone. Only a few of these
programs have actually been released, and as such, only those will have
documentation or a license. A few of these programs are released under
the GNU GPL (which will be indicated in the ZIP file), and the rest are
released into the public domain. You are free to use what you like, but
it would be nice if credit would be given to me, and I would be quite
interested to know who is using (or even looking at) my stuff. Note
that there is no guarantee that any of these programs will work, and
that I am not responsible for anything that may arise as a result of
using them.
| 83plus.zip |
These are some things that I put together after receiving my free
TI-83+ from TI after signing up to participate in their beta test
program for the TI-83+ Application SDK. About the only thing useful is a
plugin for Assembly Studio 8x to create an application (.hex) file for
the TI's 83+ simulator. I think that the sprite routine had a bug that
would cause it to draw the sprite in the wrong location (found when I
actually tried to use it a year later). |
| acz-search.zip |
This was my first attempt at a web site index and search engine
using PHP and PostgreSQL. It was also my first attempt at using regular
expressions. It turned out to be a miserable attempt, and definitely
not the way to build a site indexing engine. Some of the PHP code might
be useful, like for recursively descending into a webpage and not
looping indefinitely, similiar to the wget tool. It handled frames and
image maps. This was more of an experiment than something actually
useful. |
| alien.zip |
Rusty Wagner and I decided that
since Duke Nukem 3D was such a cool game and because it only ran under
DOS, and not Windows NT/2000 with sound, and because it only used IPX
and TCP/IP, that it would be cool to write a version of it from scratch
that ran under Win32. I wrote a class, GroupFile, to handle the GRP
files, and started work on a CON file parsing class. There is a lot of
code there for handling CON files, but due to some missing information
about how certain things work (lots of "magic" numbers), and not having
a working game engine, it never got finished. Not very useful. Rusty's
3D engine, however, was quite cool, and someone decided to take over the project. |
| asteroids.zip |
Asteroids was my first attempt to write a game with Borland
C++Builder. It is a version of Asteroids that uses polygons for
everything, based on a memory of a similiar Windows game that a lot of
played in Computer Science class at North many years ago. Most things
work, with the biggest omissions being that the player cannot die (heh),
and the lack of different levels, score, etc. Physics, asteroids,
bullets, explosions and the player's ship are all in there. |
| bin2var.zip |
I decided to try and write a program for the TI-83. However, I
couldn't get any of the tools to convert the object code into an 83P
file to work under Windows 2000. And of course, no one bothered to
release the source code to these tools. So I wrote this program to do
that job. I received several emails about the program immediately after
it was released, which prompted me to make a few updates. There are a
few more things it needs, but I've been too lazy to add them. Perhaps if
I get some more emails :) If you run Windows NT/2000, then this will be
useful, otherwise, probably not. The code will compile under Linux (or
most anything else), so this may be helpful. There aren't a whole lot of
cross-platform TI development tools available. |
| bmserver.zip |
This was a supposed to be a simple server for a chat program that I
whipped up in Builder one night as a demo for my boss. It doesn't have
any communication stuff, but has a decent interface and handles storing
users and passwords, along with logging. The code to handle MD5 hashing
might be useful, as I copied the code from the RFC and made a wrapper
function that makes using it as easy as in PHP. |
| bomberman.zip |
I decided that it would be cool to write a Bomberman game in Builder
to test out some ideas, specifically doing an action game over the
internet. Bomberman seemed like a good choice (still does), due to its
simple gameplay and complicated features, such as items and a dynamic
environment. Unfortunately, I never got that far. There are a bunch of
sprites ripped from one of the Super Nintendo versions, saved in Sprite
Studio format. Not much work was done on the actual game. |
| cas.zip |
This was another one of my crazy ideas. I was sitting in calculus
class and thinking that it actually made sense. So of course, if it
makes sense then I should be able to program it. And the TI-86 really
needs a good Computer Algebra System. But you don't sit down and write
something like that in assembly first. You write it in a high level
language. So this was my Builder prototype of how a CAS should work. My
conclusion is that they work quite well, so well in fact that I have no
idea how to program one. Ok, so I have some ideas, but it was taking
longer than a couple of days so I got bored and stopped working on it.
The program here was supposed to do some basic pretty-print, but the
actual results are far from pretty. I know what it's broken, but it
would take rewriting to fix. Maybe someday I will work on this again. I
couldn't find any books on the subject. Or any on emulators. Maybe some
smart programmer should write a book on these subjects. |
| cnc86.zip |
After giving up on the Metroid 86 project, I decided to write
Command & Conquer for the TI-86. I got as far as a mouse, scrolling
map, and partial sidebar with icons. This isn't in grayscale, and I
wasn't the best asm coder at the time, so the code could use some work.
However, it makes a nice demo of what one could do with the 86 assume he
or she had a whole lot of free time, and a good artist. |
| echat.zip |
ECHAT is a program that I wrote in preperation of adding networking
to Dark Sky. There was an FTP site, x2ftp.oulu.fi, that had a large
collection of programming tools and source code. Getting IPX networking
with Watcom under DOS/4GW was a trick. I found documentation for the
IPX protocol, including the released networking drivers to DOOM, but I
had trouble making anything work reliably. There was some example
sources for Watcom on that FTP site, but it never worked right for me.
I finally found the released Abuse source code, and it had working,
reliable networking code for Watcom. I tore into it, figured out how it
worked, cut it down and made this IPX chat program. Our school network
ran Novell with IPX, so it made a good test environment for the program.
I remembered writing and releasing this program, did a search on the
net, found it mirrored several places, re-zipped it, and upload it here.
The original filename was echat101.zip, which a quick search on Google
will find. Nothing is changed from the original release. |
| falldown.zip |
Falldown was one of those simple, yet fun and addicting games for
several TI graphing calculators. So of course, it seemed like the
perfect idea for the Bung Game Boy programming contest. This was my
second Game Boy Color game. It uses GBasm and GBlink. The game actually
only took a couple days to program, and is something that I'm actually
pleased with. I had a lot of people in dorm test it out and give me
suggestions. There seemed to be some weird issues with the ball movement
not being perfectly smooth, and I accidentally switched the a couple
letters on the high score entry screen (no one but me has noticed this
to my knowledge), but besides that, this is a complete and very playable
game. I sent a copy of it to the guys who wrote Liberty, the Game Boy
emulator for the Palm Pilot, and they gave me a free registration code
for Liberty :) This game got me a consolation prize (an Xchanger starter
kit) in the contest, which I gave to my friend James Rubingh. The game runs on both the
Game Boy and the Game Boy Color. |
| gbasm.zip |
When the Assembly Coder's Zenith
decided to get started in Game Boy development, we wanted to write an
entire IDE, complete with an assembler, linker, editor and emulator.
Rusty already had an amazing GBC emulator, so I started work on an
assembler and linker. GBasm is the assembler. It is similiar to the
assembler in Jeremy's Assembly Studio 8x, with the
exception of a full preprocessor. It only handles #include's. However,
it does handle relocatable code and local labels (a feature that I
wished Assembly Studio 8x had). Being my first assembler, the parsing
code is not as good as it could be, and it really needs to use dynamic
structures for things like the symbol table, instead of static arrays,
but overall it is a decent assembler. It worked well enough for us to
use it for all of our Game Boy development, which means it can't be too
bad. |
| gblink.zip |
This is the linker to go along with GBasm. This is about as simple
as a linker can get, but it does the job it was designed to do. |
| hgbrip.zip |
At one point, James Rubingh had a really cool screenshot of an RPG
for the TI-86 using graphics ripped from the Game Boy. I was on an RPG
kick at the time for some reason (I played through the original Final
Fantasy for the NES on an emulator) and decided that I should write a
really cool RPG for the 86. The major problem is that I am not nearly
creative enough to come up with a story line for an RPG, nor make maps,
and especially draw graphics. I figured that there would be someone who
would love to help make an RPG where all he or she would have to do is
tell me what to program, but I got very few offers for help. Graphics
would of course come from Game Boy games, so I wrote this program to rip
graphics from the HGB Game Boy emulator. If I remember correctly, using
the program involved taking a screenshot of the emulator using Alt-Print
Screen, and pushing a button in the program, which would dump the tiles
to a file for use with Graphics Studio. |
| hpiview.zip |
Someone at Loki suggested that our company, HPC Solutions, port the awsome real time
strategy game Total Annihilation to Linux using SDL. That game will be OpenTA, assuming we actually get on
with it. This program is a viewer that I wrote to view and extract the
contents of HPI files, which hold all the individual data files used by
TA. The class HPIFile is designed to be used by the game, and is a nice
class that greatly simplifies using files from an HPI file. It handles
all the files that come with TA and Core Contingency. zlib is necessary
for the CC files, so it includes a Builder library for that. It should
be able to be statically or dynamically linked with zlib. |
| isgbdk.zip |
This is a quick program I wrote to check and see if a Game Boy ROM
was compiled with GBDK or was written in assembly language (or something
else). Jimmy Mardell wrote a
version for himself in Pascal, so I decided to use his info from the
header and write one in C, and compile as a Win32 console app, so that
it could use long filenames. |
| pong.zip |
After receiving by Xchanger and finish GBasm, it was suggested to me
by Louise Stowe that Pong be my
first game for the Game Boy. That seemed like a pretty good idea, so I
wrote it. The game uses actual trig for the ball angle and movement, but
due to the collisions, the gameplay is actually pretty boring. The most
frustrating thing about writing this game was figuring out why it would
work on the Game Boy Color but not on the classic Game Boy. The gameplay
is simple, but, hey, it's pong. |
| pop3.zip |
While working at a summer programming job for the Shawnee Mission
School District, my boss showed me how I could check mail from a POP3
server using telnet. I hadn't ever thought about that before and thought
it was pretty cool. I wanted to learn WinSock programming, so I wrote a
small POP3 mail client that was similiar in feel and use to the command
line ftp client. I also discovered that some POP3 servers don't
disconnect you after a certain number of password attempts, so you could
sit there all day trying passwords using either brute force or a
dictionary file. The server used at my work was one of them, so I
decided to point this vulnerability out to my boss by writing a program
to use a dictionary file to crack a POP3 account. Some dictionary files
are included with the program. |
| slider.zip |
This is the start of a game that I was making for the TI-86, based
on a game by the same name for the Sega Game Gear. I always liked
Slider, and being a relatively simple game with 100 levels, it seemed to
be perfect for the calc. I finished the scrolling engine (which sucks),
the player movement and interface. Everything else, like items, enemies
and levels, is yet to be implemented. |
| snake86.zip |
One night in the dorms, my roommate was sitting up working on art
homework, so I decided that since I had never written a Nibbles type
game, that I should write one for the TI-86. All of the versions that
existed seemed way too large, so I figured that being a competent
programmer with a few hours of free time, that I should be able to make
a version that was signficantly smaller than all of the rest. I did a
decent job, although some other optimization freaks later made it about
half the size it was when I wrote it. Unfortunately, I only have my
original copy. |
| sstudio.zip |
When I got the idea to do Bomberman, I knew that I would need a
good way of keeping track of sprites and animations. Sprite Studio was
the result. It is a tool for handling true color bitmaps, along with
animation sequences and previews. There is a class that handles loading
and saving sprite files, which can be used in the program that needs to
make use of the sprites. This program is not the best, but writing it
taught me a lot about using Builder. |
| z_full.zip |
Dark Sky is perhaps my best project. It will always have a fond
place in my heart, possibly because it was my first large game, and
because it still amazes me that I wrote it. When doing projects, I would
always make up a one or two character name for them, and this one
happened to be named z, hence the name of the file. It was written with
Watcom C/C++, using DOS/4GW and the Stellar Game Development Kit. I
spent about a sememster working on this game during my junior year of
high school. After reading several game development books, my friend Nik Hodgkinson and I decided that
we should write a game. He thought it was better to write everything
from scratch, but I wanted to just jump in and write game code, without
worrying about all the tricky graphics code, so I bought the STGDK, and
started writing Dark Sky. I had previously started writing an overhead
shooter in C that would scroll in one direction, but I found that
writing lots of different yet similiar routines for all the different
objects like enemies and weapons didn't seem optimal. One book suggested
that C++ provided cool features useful for game development, so we
bought Teach Yourself C++ in 21 Days and I started learning C++. All of
the objects in Dark Sky make use of inheritence, which seems to be a
perfect way to do things in a game. What I have always liked about this
game is that I taught myself how to use C++ effectively while
programming it, and that it makes a better example than what many books
and programming classes try to teach. |
| zelda.zip |
Zelda 86 is my version of Zelda for the TI-86. The game is in
grayscale and the graphics are very good for a calculator. It originally
started off as being similar to the original Zelda for the NES, but
ended up being more like the Game Boy version. The readme included with
the game has a much better and longer description and history than I
will attempt to include here. I spent about six months developing this
game, let it sit on my hard drive for a year and a half after that, then
finally released it. The game is not completed, but it really shows what
can be done with the 86 if one puts the effort into it. |
