Working with Maps and Levels(15) 摘要: Recall that you need to enable
each map section in order for it to be visible when
rendered. The m_visible array tracks the visibility of each map section; if
an array
element is set to 0, the respective map section is not displayed. If the
element is set
to 1, the map section is drawn.
Working with Maps and Levels(14) 摘要: The constructor and destructor
of the cAutomap class ensure that all data is placed
within a known state and that all used resources are released. The
constructor does
nothing more than clear some variables and orient a camera to point
downward.
You later use that camera to render the map. The destructor calls on the
Free
function to release all used resources.
Working with Maps and Levels(13) 摘要: The auto map class I've
developed for the book will load a cMesh object and compress
it into a flat version of the map. The flattened map is stored in a series
of vertex
buffers. These vertex buffers use only the X-, Y-, and Z-coordinates of each
vertex plus a single diffuse color. This means that auto maps are compact
and easy
to render. This also means that you can use alpha blending to overlay the
map on
the screen without covering the crucial gaming action going on.
Working with Maps and Levels(12) 摘要: Your game world is a huge
place, and when players start exploring their surroundings,
you may want to make things easier on them by providing a miniature version
of your map for their reference. Not just any map mind you—a map that is
smart
enough to know where the player has been and the places he still needs to
explore.
Working with Maps and Levels(11) 摘要: Even though the barrier class
marks areas on the map using geometric shapes in
exactly the same way as the trigger class does, the barrier class also
positions meshes.
Looking again at the cBarrier class declaration, notice that each of the add
barrier
functions — add_sphere, add_box, add_cylinder, and add_triangle—have a set
of coordinates
that position and rotate the barrier’s mesh before being rendered.
Working with Maps and Levels(10) 摘要: Continue now with the cBarrier
class declaration:
When you need to assign a mesh to a barrier, use the set_mesh function,
passing the
barrier’s identification number to set, as well as cMesh objects to use.
For setting an animation for a barrier, you pass the barrier’s
identification number, cAnimation object, the name of the animation to use,
and the
time the animation is set (using a timer function such as timeGetTime).
Working with Maps and Levels(9) 摘要: You know—detecting when your
character is walking around the map bumping into walls or standing
on solid ground. What about objects such as doors blocking your character’s
way?
Because a door is not part of the terrain, I didn’t include a door when I
constructed
the collision detection code. Now is the time to remedy that situation.
Working with Maps and Levels(8) 摘要: The get_enable_state function
checks the current status of a trigger; by passing the
trigger identification number, you get in return the state of the trigger.
If a trigger
is disabled, a call to get_enable_state returns a value of false. If
enabled, the return
value is true. To enable or disable a trigger, call on the enable function,
using the
trigger's identification number as the only argument.
Working with Maps and Levels(7) 摘要: get_trigger is the function in
the trigger class that you call every time the player’s character
moves. get_trigger will take the coordinates of the character you are
checking and
return the identification number of the first trigger found at that location
(if any). If
no triggers are found at the specified location, get_trigger returns a value
of zero.
Working with Maps and Levels(6) 摘要: add_trigger is the heart of all
the other functions that add a trigger. This function
allocates a sTrigger structure, sets its type, identification number, and
enable flag,
and then links the structure into the linked list of triggers. Once you
allocate your
program using the add_trigger function, the program can fill in the returned
sTrigger
structure with the coordinates, radius, height, or whatever other
information the
trigger needs to have defined.
Working with Maps and Levels(5) 摘要: Just as does every C++ class,
cTrigger has a constructor and a destructor that set up
and free the data contained within the class. The only data tracked by the
trigger
class that is not contained with the linked list is the number of triggers
currently
held in the linked list and a pointer to that linked list. The constructor
and
destructor ensure that the class is prepared for using those two variables
to free
the class's data when destroyed (by calling the free function).
Working with Maps and Levels(4) 摘要: Adhering to object-oriented
programming techniques, create a class that will handle
a list of triggers and determine which (if any) has been touched by a
character. The
class uses a structure to store the information of each trigger—the
coordinates, type,
and so on. Each trigger is also assigned an identification number that it
uses to refer
back to itself. The entire list is maintained as a linked list of
structure.
Working with Maps and Levels(3) 摘要: You define sphere triggers (see
Figure 17.1) by a set of coordinates and a radius.
Sphere triggers have two unique benefits:
■ Spheres are perfect for defining large areas of a map as a trigger, only
using
the center coordinates and a radius to define the location of the sphere.
■ The sphere trigger is one of the fastest ways to check for
character-to-trigger
collisions in the map trigger engine.
Working with Maps and Levels(2) 摘要: Using character map lists is a
quick way to place characters in a map. When you
load a map into memory, load the matching character map list and insert the
characters.
Although this method of adding characters to a map seems desirable, you’ll
need a bit more flexibility at times, and that’s when using scripts comes
into play.
Working with Maps and Levels(1) 摘要: While going through the
examples, I placed characters on the map in
a direct, hard-coded manner. However, remember that hard-coding game data is
a
no-no. You need to have as much flexibility as possible when designing your
maps,
and this includes placement of characters in a level.