04 February 2023
I’ve been coding for a very long time, so I’ve had lots of projects in various languages, on various platforms, and stored very differently.
I got nostalgic on and off over the past couple years and went digging around to recover the source for some of those old projects. I uploaded the more notable projects to my GitHub account.
I spent money to buy a 3.5-inch USB floppy drive and an old 386 PC with a 5.25-inch and 3.5-inch floppy drive, so I could ultimately copy files from really old 5.25-inch floppies that I used in the late 1980s and early 1990s to my live storage of today. Among those old files were binaries and source in GWBASIC and QuickBasic.
I found one of the first games I wrote and sort of distributed, Gravity Blocks. I could play the compiled binary with DOSBox and read the main source file, but some of the source code for my common libraries is still locked up in a compressed format from QuickBasic 4.5. I may need to dig deeper into QB64, a clone of QuickBasic 4.5 that seems to be able to read, run, and compile those old compressed files.
I also found source code for the first software I wrote for the local fire company to help track statistics on calls and print reports to submit to the local municipalities we served.
It was written in GWBASIC, so I was able to decode the compressed source where needed to read it. I published my CALL-REP source, so I could go back and have a look at the simple, but useful, things I used to write as a kid.
I continued to build stuff through college (and obviously beyond). Some of it was in C, PERL, and Java.
I recovered these bits
of source code
laying around in backups and copies
of old Linux servers I’ve run
over the years.
This source was in old Subversion repositories
that used old versions of Berkeley DB.
This BDB version mismatch
svn checkout from working,
but the current Subversion tools
svnadmin recover command
that could fix the repository
for normal reading today.
I’m sure some
of those old SVN repositories
had previously been migrated
I found the source code from my final project in the Java class in my last year of college in 2000.
Pop-a-Prof is a clone of my favorite puzzle game, Bust-a-Move. It’s a Java Applet that ran in Netscape allowing any number of players, and it coordinated everyone’s play with a shared public server, Each round lasted 5 minutes, and any time you topped-out, you’d lose some points, and start over, so no one needed to sit around watching the last people battle it out.
After school, I started on Pop-a-Prof 2. This one ran as a plain Java application, and implemented rebounding balls in the game. It was more of a proof-of-concept for the new game mechanics, and it never got network play.
I liked running little bits of code, like applets did, so I continued into writing Java ME (J2ME) for my feature phones around 2005.
I did a gas-logging app that stored fuel-ups and drew graphs to show fuel economy.
I also wrote a quick little game called Ben’s Backhoe to give the kids a little something to do on my phone. By the time I was building this sort of thing, though, I’m a decent Java programmer, so it’s not the fun mess that we see in the other old project.
I spent most the day poking around at various old BASIC files and trying to tweak them a bit to run in PCBasic or QB64. I used lots of weird graphics modes from the Tandy 1000 and didn’t think much about portability. I may post more projects over time.
14 January 2018
Polarity is a game of placing magnetic discs so that they lean on the magnetic fields of others. It went out of print a while ago, so I wanted to make a scaled-down version of my own with some 3D-printed pieces. I left out some aspects of the original game.
The rules had always been a bit confusing, so I’ll try to distill a set of my own rules here.
Be the first to play all discs in your supply.
Collect the most discs in towers, stacks of discs.
Roll out the playing mat flat on a stable surface.
Give each player half the discs for their supply: 19 to each player.
Players take turns placing foundation discs flat on the mat, touching no others, until each player has placed 4 foundations.
Take turns leaning discs from your supply on magnetic fields of your discs on the mat.
Play only on the mat.
Play only on your own discs with your color facing up, not on your opponent’s discs.
A turn ends by successfully placing a disc or by causing a fault.
Play ends immediately upon causing a fault, so pieces still in the hand are returned to the player’s supply.
Faults occur 4 ways:
A leaning disc falls flat.
2 or more discs touch each other.
Moving a tower or foundation disc more than its diameter.
Knocking a disc off the mat.
A player can intentionally cause a fault to convert a leaning disc into a new foundation.
A player can only convert their own discs.
The fault still ends their turn.
Faults are resolved by:
If discs snap to the disc being placed while still in the hand, the player removes the touching discs and returns them to their supply.
If discs on the board are touching, the opponent carefully retrieves the discs allowing them to snap the rest of the way to form a tower, and places it anywhere on the mat.
While retrieving or placing a tower, the tower is treated like a disc being placed, so causing a fault should be resolved the same way as when placing a piece.
If a disc just fell, but stayed the same color (a conversion), it stays where it is, but the turn ends.
If a fault flips one disc from one color to the other, without otherwise touching other discs, the opponent can choose to retrieve the disc and place it anywhere on the mat.
A player is responsible for any faults after a move until the opponents hand approaches the mat.
The game ends when one player depletes their supply.
A player no longer has any discs with their color showing left on the board.
Each disc in a tower is worth +1 point.
Each disc in the supply is worth -1 point.