So the other day in about a night I used Batari BASIC to code up a
simple idea I had for a "drumpad" program:
http://www.atariage.com/forums/index.php?showtopic=72428&view=findpost&p=894817
Unfortunately, the sound lag in most emulators means it's not very fun
when not on the real 2600 hardware.
But the ease of doing that floored me; it would have taken me at least
a week to get my 6502 chops back and code this, maybe longer, and
maybe I never would have gotten the energy for it. (I know some people
here eat drink and breath in assembly, but I've never gotten quite
fluent.)
Theoretically, it should just be the "generic kernal" that's making
life so much easier, but in practice, the BASIC-like syntax is much
easier for the non-native-6502 speaker. Writing JoustPong I was always
having to carefully reformulate every math comparison and what not.
(Actually, if I wanted to code just in 6502, writing it in BASIC and
examing the generated .asm file would be a big hand, everything still
maps pretty closely between BASIC statement and generated 6502.)
It's interesting playing "what if" -- if this had been out in 2002 or
so. Porting JoustPong using it would be a no brainer. And I would
probably still think of myself as a "2600 coder", even though I would
have worked so much less hard to get there.
The previous barrier to learning how to code an Atari game really made
it kind of elite thing, (even though I tried to lower it a bit with my
2600 101 tutorial) and that's shifted somewhat. It seems to be
splitting hairs to say "I programmed a game for the 2600 in Assembly
Language" vs "I programmed a game for the 2600" even though the former
is a big achievement in a way the latter isn't. You used to have to
gain this expertise in archaic things to make a game that could run on
the real hardware...now the particulars of that pursuit seem a bit
quaint and oddball, since there's a much better effort/reward ratio to
just doing it in "BASIC".
So right now the single kernal is pretty limiting, though Quimby's
idea of making a 32*12 playfield mapped to memory opens up some gaming
ideas. As the language matures, and more kernals are made for
it...games probably won't be at the top tier, but still.
Heh, one downside is learning how to do simple game logic in ASM was
probably a useful ramp up to actually writing kernals...the learning
curve between BASIC and kernals is a quantum leap, relative to game
logic and kernals.
Anyway, I wonder what you all think of this. An upcoming flood of
small, simple homebrews makes me feel different about what I've
achieved I think.
-Kirk
Archives (includes files) at http://www.biglist.com/lists/stella/archives/
Unsub & more at http://stella.biglist.com
