At 06:02 PM 5/18/2000 -0700, you wrote:
So, it just makes three copies of the players for each
row and spaces them so that they alternate, or does it
draw one invader and, as it switches to the other
player, move the sprite over so it gets drawn again?
The 2600 handles sprite cloning in hardware automatically.
Therefore the program only has to set the shapes, color, and then run a
positioning routine for two sprites and the 2600 does the rest. Because
the spacing is set to wide, you can use one of the other players to fill
the gaps between the copies of the other.
P1 P2 P1 P2 P1 P2
Not to be too much of a pitchman, but this technique is explained in more
visual (albeit no code samples) terms on Stella at 20: Volume 2. Not too
many people have bought the tape vs. the CD so I thought I'd point out its
usefulness to potential 2600 programmers, since I'd imagine that group
would get the most out of it vs. the regular classic gamer.
The video also shows other tricks like the Video Chess kernel, and the
moving "6 char" for Dragster, which is an elaboration of what was done in
Space Invaders.
BTW, I've heard that it was Blackjack that first rewrote sprite shapes
inbetween copies. Has anyone disassembled that game? It seems like card
and board games aren't games that people often disassemble and analyze. It
doesn't build a megasprite, but appears to use the other sprite as a way to
paint underneath the card icons using sprite priority.
So, if I can run with this ball, to draw the other
asteroids in progressively smaller sizes, because it
can clone the images but not change sizes, it draws
the different sized asteroids on seperate frames,
right?
I think the asteroids only fly in two different speeds, and then there is
an option for how diagonal the small ones fly. It's a pretty complicated
kernel, I'm sure, because of how the sprites have to break off and fly
around, which complicates things, which is why Asteroids is one of if not
the first 8K game. I'm sure the flickering could have been minimized by a
more intelligent kernel, but it's still a good one as it is.
Let me give you an example of a kernel idea that probably hasn't been done
that much, that I just thought of.
Assuming you can have 6 strips of sprites running down the screen (ala
Space Invaders) and you can change their shape between copies (like
Dragster) then you could create vertical independence between the
'sprites', with the simulation of six (or more, as long as they don't run
into eachother vertically, in which case they'd have to be the same color)
sprites or flickered. You just couldn't move an individual sprite
horizontally, they'd have to move as a group. If you wanted the illusion
of the sprite moving into the other "lane" you'd have to shift the data
over where part is written to sprite one and part to sprite one copy two,
and so on.
Most games run sprites along horizontal rails so that they can get two
groups of sprites, 1, two, or 3 copies a piece, and slide them back and
forth. Megamania and Oystron are good examples of that. Other games like
Journey Escape do regular sprite clones and then scroll those down. But by
rewriting the sprite shapes, you could then not only control the vertical
position of the sprite, but all of its clones by simply deciding where and
when to write the other shapes into the other copies.
Do any games use this sort of kernel??
Of course, taken to its extremes, you get the Suicide Mission kernel, which
just lets you draw arbitrarily on the screen (at the cost of flicker and
spread out pixels) or Stellasketch. At that point you basically are
superimposing software sprites onto a matrix of hardware sprites. But it's
really cool that these things are possible.
Glenn Saunders - Producer - Cyberpunks Entertainment
Personal homepage: http://www.geocities.com/Hollywood/1698
Cyberpunks Entertainment: http://cyberpunks.uni.cc
--
Archives (includes files) at http://www.biglist.com/lists/stella/archives/
Unsub & more at http://www.biglist.com/lists/stella/
