I remember my first line of code, a conditional statement to handle
pressing Enter, copied from the Microsoft Visual Basic 6.0 manual when
I was 8 years old.
"If KeyAscii = 13 Then"
Without teachers or books, it was a lot of experimentation, making
small apps and games in the worst way imaginable, but we all started
somewhere, right?
Eventually I would connect with other developers on the world wide web,
and I owe a lot to them for helping me along the way.
I toyed with Visual Basic 6.0 for years, eventually learning about
DirectX libraries like DirectDraw to render 2D graphics and tilemaps.
(I really love tilemaps.)
After finding a ripped sprite sheet of Mario graphics, I made my own
iteration of "Super Mario."
Having never played the original game before, it was a...unique result.
The source code, complete with custom map editors, is stuck somewhere
on old zip disks.
When I was 14, I sold my first game. It was a GameBoy Advance console
port of one of my PC games, Jetpack, published in
MaxPlay Classic Games Volume 1
.
Scroll down to read more or watch a review.
I taught myself C from resources like cprogramming.com, and I learned
about console programming from The PERN Project (Nintendo Reverse
Engineering Project) by
@dovoto.
The GameBoy Advance had an incredible homebrew community, and I'm glad
to have been a part of it.
In early 2004, a company reached out to #gbadev (EFNet) with an
interest to buy indie games for publishing. The deadline was one month,
and I worked non-stop to port my PC game to the GameBoy Advance.
It wasn't easy, but I got it done, and they accepted it.
Jetpack 4
In 2003, after finishing several small games, I had created Jetpack 4,
which was a four-player (via split-screen and gamepads) sidescroller
with open-ended gameplay. Fly around, blow stuff up, build, and hurt
each other. It was developed in Visual Basic using DirectDraw for
graphics.
My friends would come over and we'd play this game for hours on end. I
would go on to write several revisions and patches over the years for
more to play with.
The game features 50 levels, all designed in my easy to use graphical
level editor. Knowing Visual Basic really comes in handy.
An Adventure Into Assembly
Around this time I started gaining an unhealthy fascination with
writing assembly language. The tiny binary sizes were just so cool.
By now I've seen a lot of different flavors, including Z80, 6502,
65816, 68K, SPC-700, ARM, and x86. Those are 8-bit, 16-bit, and
32-bit+ computers.
In 2007, I installed MS-DOS on my
Pentium 4 laptop
and then proceeded to write C and x86 assembly in edit.exe (to taste
the authentic early 90s developer experience).
The source code for my x86 projects are unfortunately on a defunct
hard drive, but one project was a 3D renderer for DOS with an
assembly-optimized rasterizer (complete with perspective correction!).
It wasn't long before I learned that the incredible engineering behind
the x86 processor renders hand-coded assembly
basically useless.
A commercial-quality music and sound engine written entirely in ARM
assembly language.
The above example is running on the Nintendo DS. It features taking
advantage of the 16-channel hardware mixer while extending that to 30
channels with software mixing.
The library targets both the GameBoy Advance and the Nintendo DS.
Check out the
documentation.
Being written completely in assembly, the binary size on the GameBoy
Advance is only around 10KB.
Bringing it to Flash
After noting my work done on tracker-based sound solutions,
@StoneCypher contracted
me to build something for the Flash platform, a means to deliver great
soundtracks at a fraction of the bandwidth.
I put the latest Flash technology to the test, leveraging the new
JIT-optimized ActionScript 3 engine and their audio API to mix dynamic
PCM channels realtime, one of the first projects to do so.
I've had my fair share of fun making the Nintendo Entertainment System
do very strange things.
Below is a recording of
SuperNSF,
a crazy audio driver I wrote that has the ability to combine
software-mixed PCM and NES hardware waveforms (which is quite
difficult).
The NES does not have hardware to time PCM playback. All it has is one
register that you can manually feed a single sample to.
For each block of code in the SuperNSF driver, I needed to keep track
of the exact cycle count (yes, counting everything manually) so I could
time the software mixer which outputs a single sample at a time.
For example (and forgive me for not remembering exact numbers), the NES
has a 1.79 MHz computer. Divide that speed by 10,000 for a 10KHz
sampling rate, and you have 179 cycles to mix PCM channels, output a
single sample, and then process the music sequence. A few uncounted
cycles means a pitch shift in the output.
I used an array of no-op instructions to manually insert cycle delays
and line everything up.
I'm impressed that most emulators are cycle-accurate and support
SuperNSF.
Any slight inaccuracy in emulation would result in massive pitch
shifts.
PCMNSF
SuperNSF was based off of some previous tinkering I did with @tumult
from #mod_shrine called
PCMNSF, which was a
simpler 4-channel MOD player.
#mod_shrine
Sometime in 2006, I joined #mod_shrine on EsperNet, a fantastic
community that revolves around the greatness of tracker-based music.
I had been fascinated by music and sound drivers for a while and even
tried my hand at making music compositions myself.
#mod_shrine regularly hosts one-hour music competitions, even today,
where people create music for an hour using a given sample set and
then listen together. I did around 350 of these some ten years ago.
These guys have been a big part of my life, and if you're one of them
reading this, you're awesome! We've made music, games, and amazing
tools together.
it2nsf
A less abusive tool I wrote was
it2nsf. It supports
MML (music macro language) techniques to create unique instrument
sounds while providing a tracker-friendly method for composition.
The PC side of things generates samples that emulate the final sound
from the NES driver which musicians can use to compose their track
easily.
The NES sound driver is written in 6502 assembly, and the tool side is
written in C++.
s3m2nsf
The precursor to it2nsf,
s3m2nsf is a simpler
version that supports basic waveforms and allows tracker fans to easily
write music that plays on the NES.
The conversion app was coded by the amazing
@reduz, a member of the
#mod_shrine community. I wrote the 6502-based S3M player in assembly
code.
The 1st place winner of PDRoms competition #4.01. I'm proud to be one
of very few developers to create a complete Super Nintendo game from
scratch. Everything is written in assembly language.
I found out recently that someone even wrote a
full walkthrough for this game. Very cool, @Lanzz.
The competition deadline was two months, and I didn't have any time
leftover.
The first month was spent designing and building
SNESMOD, an Impulse
Tracker-based sound and music engine that rivals commercial legends. I
used what I learned from making XMSNES (described below) and pushed the
boundaries.
SNESMOD supports streaming PCM sounds from the SNES cartridge, all
nightmarishly implemented
on a 500khz computer.
Tooling, documentation, and examples were all extremely limited
or nil.
The game had stickmen graphics all the way until the last week before
the deadline, but @coda
pitched in and did some animation work while I worked on adding all of
the levels in a complex map editor I built with Visual Basic.
Ask me about the story one hour before the deadline, when I decided the
game needed a final boss.
Cyclone Aila
was right outside.
A few years after the release, Piko Interactive contacted me to have
Skipp and Friends
published on cartridge.
XMSNES
XMSNES is an XM module player for the Super Nintendo and the precursor
to SNESMOD. What better way to get into SNES programming than writing
the hardest things possible?
Similar to SNESMOD, XMSNES comes with a converter and sound driver that
was split across the two processors in the SNES.
Below shows a test demo of it, something that required me to rewrite a
hardware cartridge hundreds of times (and stick it in the console, and
boot it, and test via looking at those byte outputs on-screen) to track
some of the bugs during development.
The joys of programming, right?
When Counter-Strike: Global Offensive was released, I became a part of
Reflex Gamers and found a deep
fascination in the flexibility of the Source engine.
I made a ton of neat and crazy things.
What happens when you push the red button? All players get sucked into
the anti-gravity well!
I used Sony Vegas to compose the sound effects.
Pirate Wars
This was an event that I created and hosted featuring a custom map,
ridiculously modified elements, and completely destroyble ships.
Game-server Plugins
I coded a lot of
customizations for the game-servers we hosted in our community.
The Source engine is super fun to experiment with.
ServerTools
To manage our growing plugin list and server files,
I wrote a handful of
tools to help out, complete with a plugin packaging system.
This is a video of the early development phase of my Tetris game. I
made the office lounge map, too, my personal test environment with a
TV.
And this is the finished product.
Super Mareo Bruhs
Tetris wasn't the only game I made for this virtual console. I made a
Mario game, first.
The gameplay was purposely designed for expert players to be able to
speed-run through it while killing everything and collecting all of the
coins. Here is me doing a perfect clear.
A smooth scrolling tilemap with clipped edges? The more familar you are
with the Source engine, the more impossible this seems.
The sound effects were ripped from an
amazing video
made by Jake "virt" Kaufman, another extremely talented someone I
met in #mod_shrine.
In 2014, @WhiteThunder
and I put together a store
site for our community. I built most of the PayPal integration
while he worked on a fantastic frontend.
I designed the interface between the site and our game-servers, and
then created several virtual items that can be bought on the store and
then used in-game via
custom plugins.
One of the items on the menu crashes the server and costs $100. Well
worth the price? Yes! According to one of our customer's positive
review.
RXG Demos
Another service I created for our game-servers was an automatic demo
recorder.
Source games typically have the ability to record gameplay,
and I wrote a server modification to automatically transfer those
gameplay files to a publicly
viewable repository, complete with meta information.
The web side is written in PHP, with a sort of REST API exposed to
upload and register demos.
A Fancy Application
This year, for one of the communities I'm a part of, I designed an
application site.
I felt like the Google Forms aesthetic was unappealing, so I had some
fun implementing this solution.
The front-end is HTML/CSS and JavaScript + jQuery, with a back-end
written in Python and JavaScript, using Google Apps Scripts to generate
and modify Google Documents for record keeping.
It also integrates with Discord to post notifications whenever an
application is submitted or changed.
In late 2014 I opened the Java manual, read it from top to bottom (it
took three days), and directly after I was writing robust Java code,
complete with proper packaging practices, database work, JavaDoc
comments, and safe concurrent programming. How's that for fast
learning?
I actually really like how the Java manual is written.
I was working on creating a new experience for Minecraft players, but
sadly due to the new legal issues Bukkit faced, I decided to put that
project on the shelf.
I haven't written Java in a while, but it is certainly up there on
likeable languages for me.
This is a picture of over a thousand players in World of Warcraft
gathering after an amazing virtual fair in 2018, the annual Tournament
of Ages on Moon Guard.
That year was particularly special because my project allowed players
of both factions to talk to each other freely, something completely
unthinkable before.
Just before the release of Battle for Azeroth, I created Cross RP,
using the newly released "Communities" feature to bridge the language
divide between factions, blowing away the gates for cross-faction
role-play enthusiasts.
It had a massive welcoming, with a
huge event on Argent Dawn-EU being the first to use it.
I would credit a lot of Cross RP's viral adoption to its design
principles. Here are some points that were bulleted in the source code
at the start.
It's also just plain amazing. I get carried away when it comes to
attention to detail.
A typical implementation would just translate text in the chatbox, but
I wanted the chat bubbles to be translated too.
This is an early video before I redid the communications layer to
synchronize translation data with outgoing chat, so the translations
don't have the short delay shown. Instant and seamless.
It's Part of the Game Now
Some months after the release, Blizzard changed the API Cross RP was
depending on, permanently breaking it.
They stated that it
was an unfortunate side effect of addressing security concerns and then
introduced the
Elixir of
Tongues to compensate, essentially providing Cross RP's
functionality officially. Thanks Blizzard!
I still had to rework my code to transfer character profile data across
the faction divide (basically doing the impossible).
I'll spare you the details unless you ask, but I essentially built a
peer-to-peer network and protocol, turning some of my userbase into
routers to smuggle data across the Battle.net platform.
I Love UI Tinkering
I've written
multiple popular addons that their users can't live without, as
well as
a ton of other UI modifications. I can really appreciate platforms
and games that offer this flexibility for developers like myself.
I was the #1 survival hunter in the world for a few days during Emerald
Nightmare mythic progression. It was one of the hardest specializations
to play, but I designed an
incredible UI to trivialize it.
It's pretty cool, isn't it? The background is WebGL with custom
shaders, all powered by vanilla JavaScript.
That's right, this isn't using any libraries or frameworks; I wrote it
all from scratch. Have a look at
the code - I didn't
minify or webpack it.
The math was
especially tedious. Notice how the cube edges stay aligned with the
text scroll?
It all feels pretty smooth, doesn't it?
Having worked so long with apps and computers, I have a strong sense
for how things should behave. There's a lot of attention to detail
here.
It painstakingly works fairly well on mobile, too.
iOS/Safari might be a little wonky...
It's been a long, fun journey, through C, C++, assembly code,
JavaScript, Python, PHP, Lua, Basic, HTML, CSS... but I've hardly
scratched the surface of the ever-evolving world of technology.
What's Your Story?
That's enough about me. What about you? How did you become who you
are? I want to know.
Call me,
write me,
or @ me.
Let's connect.
Maybe we'll work on something great together.