?? ch6.htm
字號:
<HTML>
<HEAD>
<TITLE>Chapter 6 -- Sprite Animation</TITLE>
<META>
</HEAD>
<BODY TEXT="#000000" BGCOLOR="#FFFFFF" LINK="#0000EE" VLINK="#551A8B" ALINK="#CE2910">
<H1><FONT COLOR=#FF0000>Chapter 6</FONT></H1>
<H1><B><FONT SIZE=5 COLOR=#FF0000>Sprite Animation</FONT></B>
</H1>
<P>
<HR WIDTH="100%"></P>
<P>
<H3 ALIGN=CENTER><FONT COLOR="#000000"><FONT SIZE=+2>CONTENTS<A NAME="CONTENTS"></A>
</FONT></FONT></H3>
<UL>
<LI><A HREF="#WhatIsAnimation" >What Is Animation?</A>
<LI><A HREF="#TypesofAnimation" >Types of Animation</A>
<UL>
<LI><A HREF="#FrameBasedAnimation" >Frame-Based Animation</A>
<LI><A HREF="#CastBasedAnimation" >Cast-Based Animation</A>
</UL>
<LI><A HREF="#ImplementingSpriteAnimation" >Implementing Sprite Animation</A>
<UL>
<LI><A HREF="#TheSpriteClass" >The Sprite Class</A>
<LI><A HREF="#TheSpriteVectorClass" >The SpriteVector Class</A>
<LI><A HREF="#TheBackgroundClasses" >The Background Classes</A>
</UL>
<LI><A HREF="#SampleAppletAtoms" >Sample Applet: Atoms</A>
<LI><A HREF="#Summary" >Summary</A>
<LI><A HREF="#QA" >Q&A</A>
<LI><A HREF="#Workshop" >Workshop</A>
<UL>
<LI><A HREF="#Quiz" >Quiz</A>
<LI><A HREF="#Exercises" >Exercises</A>
</UL>
</UL>
<HR>
<P>
The heart of graphics in almost all games is animation. Without
animation, there would be no movement, and without movement, we'd
all be stuck playing board games and card games. Today's lesson
presents the fundamental concepts surrounding animation in games
and, more specifically, sprite animation. As you'll soon learn,
practically every game with animation employs some type of animation
engine, typically involving sprites.
<P>
After learning the basics of animation and how it applies to games,
you dig into building a set of sprite animation classes that are
powerful and extensive enough to handle all of your Java game
animation needs. As a matter of fact, you'll reuse the sprite
classes in every game throughout the rest of the book. These sprite
classes handle all the details of managing multiple animated sprite
objects with support for transparency, Z-order, collision detection,
and custom actions. You don't understand some of those last features?
Well, don't worry; you will soon enough. Read on!
<H2><A NAME="WhatIsAnimation"><B><FONT SIZE=5 COLOR=#FF0000>What
Is Animation?</FONT></B></A></H2>
<P>
Before getting into animation as it relates to Java and games,
it's important to understand the basics of what animation is and
how it works. Let's begin by asking this fundamental question:
What is animation? Put simply, animation is the illusion of movement.
Am I saying that every animation you've ever seen is really just
an illusion? That's exactly right! And probably the most surprising
animated illusion is one that captured attentions long before
computers-the television. When you watch television, you see lots
of things moving around. But what you perceive as movement is
really just a trick being played on your eyes.
<P>
<I>Animation</I> is the illusion of movement.
<P>
In the case of television, the illusion of movement is created
by displaying a rapid succession of images with slight changes
in content. The human eye perceives these changes as movement
because of its low visual acuity, which means that your eyes are
fairly easy to trick into believing the illusion of animation.
More specifically, the human eye can be tricked into perceiving
animated movement with as low as 12 frames of movement per second.
It should come as no surprise that this animation speed is the
minimum target speed for most computer games. Animation speed
is measured in frames per second (fps).
<P>
<I>Frames per second</I> (fps) is the number of animation frames,
or image changes, presented every second.
<P>
Although 12 fps is technically enough to fool your eyes into seeing
animation, animations at speeds this low often end up looking
somewhat jerky. Therefore, most professional animations use a
higher frame rate. Television, for example, uses 30 fps. When
you go to the movies, you see motion pictures at about 24 fps.
It's pretty apparent that these frame rates are more than enough
to captivate your attention and successfully create the illusion
of movement.
<P>
Unlike television and motion pictures, computer games are much
more limited when it comes to frame rate. Higher frame rates in
games correspond to much higher processor overhead, so game developers
are left to balance the frame rate against the system speed and
resources. That is why some games provide different resolution
and graphics quality options. By using a lower resolution and
more simple graphics, a game can increase its frame rate and generate
smoother animations. Of course, the trade-off is a lower resolution
and more simple graphics.
<P>
When programming animation in Java, you typically have the ability
to manipulate the frame rate a reasonable amount. The most obvious
limitation on frame rate is the speed at which the computer can
generate and display the animation frames. Actually, the same
limitation must be dealt with by game developers, regardless of
the programming language or platform. However, it is a little
more crucial in Java because Java applets are currently much slower
than native applications. Hopefully, the advent of just-in-time
Java compilers will speed up Java applets and therefore give Java
games a boost.
<P>
When determining the frame rate for a Java game, you usually have
some give and take in establishing a low enough frame rate to
yield a smooth animation, while not bogging down the processor
and slowing the system down. But don't worry too much about this
right now. For now, just keep in mind that when programming animation
for Java games, you are acting as a magician creating the illusion
of movement.
<H2><A NAME="TypesofAnimation"><B><FONT SIZE=5 COLOR=#FF0000>Types
of Animation</FONT></B></A></H2>
<P>
Although the focus of today's lesson is ultimately on sprite animation,
it is important to understand the primary types of animation used
in Java programming. Actually, a lot of different types of animation
exist, all of which are useful in different instances. However,
for the purposes of implementing animation in Java, I've broken
animation down into two basic types: frame-based animation and
cast-based animation.
<H3><A NAME="FrameBasedAnimation"><B>Frame-Based Animation</B></A>
</H3>
<P>
The most simple animation technique is frame-based animation,
which finds a lot of usage in nongaming animations. Frame-based
animation involves simulating movement by displaying a sequence
of pregenerated, static frame images. A movie is a perfect example
of frame-based animation: Each frame of the film is a frame of
animation, and when the frames are shown in rapid succession,
they create the illusion of movement.
<P>
<I>Frame-based animation</I> simulates movement by displaying
a sequence of pregenerated, static frame images.
<P>
Frame-based animation has no concept of a graphical object distinguishable
from the background; everything appearing in a frame is part of
that frame as a whole. The result is that each frame image contains
all the information necessary for that frame in a static form.
This is an important point because it distinguishes frame-based
animation from cast-based animation, which you learn about next.
<H3><A NAME="CastBasedAnimation"><B>Cast-Based Animation</B></A>
</H3>
<P>
A more powerful animation technique employed by many games is
cast-based animation, which is also known as <I>sprite animation</I>.
Cast-based animation involves graphical objects that move independently
of a background. At this point, you might be a little confused
by the usage of the term <I>graphical object</I> when referring
to parts of an animation. In this case, a graphical object is
something that logically can be thought of as a separate entity
from the background of an animation image. For example, in the
animation of a space shoot-em-up game, the aliens are separate
graphical objects that are logically independent of the starfield
background.
<P>
<I>Cast-based animation</I> simulates movement using graphical
objects that move independently of a background.
<P>
Each graphical object in a cast-based animation is referred to
as a <I>sprite</I>, and can have a position that varies over time.
In other words, sprites have a velocity associated with them that
determines how their position changes over time. Almost every
video game uses sprites to some degree. For example, every object
in the classic Asteroids game is a sprite that moves independently
of the background.
<P>
A <I>sprite</I> is a graphical object that can move independently
of a background or other objects.
<P>
<CENTER><TABLE BORDERCOLOR=#000000 BORDER=1 WIDTH=80%>
<TR><TD><B>Note</B></TD></TR>
<TR><TD>
<BLOCKQUOTE>
You might be wondering where the term <I>cast-based animation</I> comes from. It comes from the fact that sprites can be thought of as cast members moving around on a stage. This analogy of relating computer animation to theatrical performance is very
useful. By thinking of sprites as cast members and the background as a stage, you can take the next logical step and think of an animation as a theatrical performance. In fact, this isn't far from the mark, because the goal of theatrical performances is to
entertain the audience by telling a story through the interaction of the cast members. Likewise, cast-based animations use the interaction of sprites to entertain the user, while often telling a story.
</BLOCKQUOTE>
</TD></TR>
</TABLE></CENTER>
<P>
<P>
Even though the fundamental principle behind sprite animation
is the positional movement of a graphical object, there is no
reason you can't incorporate frame-based animation into a sprite.
Incorporating frame-based animation into a sprite enables you
to change the image of the sprite as well as alter its position.
This hybrid type of animation is actually what you will implement
later in today's lesson in the Java sprite classes.
<P>
I mentioned in the frame-based animation discussion that television
is a good example of frame-based animation. But can you think
of something on television that is created in a manner similar
to cast-based animation (other than animated movies and cartoons)?
Have you ever wondered how weatherpeople magically appear in front
of a computer-generated map showing the weather? The news station
uses a technique known as <I>blue-screening</I>, which enables
them to overlay the weatherperson on top of the weather map in
real time. It works like this: The person stands in front of a
blue backdrop, which serves as a transparent background. The image
of the weatherperson is overlaid onto the weather map; the trick
is that the blue background is filtered out when the image is
overlaid so that it is effectively transparent. In this way, the
weatherperson is acting exactly like a sprite!
<H4><B>Transparency</B></H4>
<P>
The weatherperson example brings up a very important point regarding
sprites: <I>transparency</I>. Because bitmapped images are rectangular
by nature, a problem arises when sprite images aren't rectangular
in shape. In sprites that aren't rectangular in shape, which is
the majority of sprites, the pixels surrounding the sprite image
are unused. In a graphics system without transparency, these unused
pixels are drawn just like any others. The end result is sprites
that have visible rectangular borders around them, which completely
destroys the effectiveness of having sprites overlaid on a background
image.
<P>
What's the solution? Well, one solution is to make all of your
sprites rectangular. Because this solution isn't very practical,
a more realistic solution is transparency, which allows you to
define a certain color in an image as unused, or transparent.
When pixels of this color are encountered by drawing routines,
they are simply skipped, leaving the original background intact.
Transparent colors in images act exactly like the weatherperson's
blue screen in the example earlier.
<P>
<I>Transparency colors</I> are colors in an image that are unused,
meaning that they aren't drawn when the rest of the colors in
the image are drawn.
<P>
You're probably thinking that implementing transparency involves
a lot of low-level bit twiddling and image pixel manipulation.
In some programming environments, you would be correct in this
assumption, but not in Java. Fortunately, transparency is already
supported in Java by way of the GIF 89a image format. In the GIF
89a image format, you simply specify a color of the GIF image
that serves as the transparent color. When the image is drawn,
pixels matching the transparent color are skipped and left undrawn,
leaving the background pixels unchanged.
<H4><B>Z-Order</B></H4>
<P>
In many instances, you will want some sprites to appear on top
of others. For example, in a war game you might have planes flying
over a battlefield dropping bombs on everything in sight. If a
plane sprite happens to fly over a tank sprite, you obviously
want the plane to appear above the tank and, therefore, hide the
tank as it passes over. You handle this problem by assigning each
sprite a screen depth, which is also referred to as <I>Z-order</I>.
<P>
<I>Z-order</I> is the relative depth of sprites on the screen.
<P>
The depth of sprites is called <I>Z-order</I> because it works
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -