Programming page

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. 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). 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. 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 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. 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. 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. 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. 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. 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 is a program that I wrote in preperation of adding networking to Dark Sky. There was an FTP site,, 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, which a quick search on Google will find. Nothing is changed from the original release. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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 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.

© 2001 David Phillips Valid
HTML 4.01!