void
PlayerImage::updateLegsDrawingInfo() {
// Remove old data, if applicable
if(mLegsSurface != NULL) {
SDL_FreeSurface(mLegsSurface);
mLegsSurface = NULL;
}
if(mLegsData != NULL) {
free(mLegsData);
mLegsData = NULL;
}
mLegsValid = false;
// Get the player shape definitions
player_shape_definitions* theShapeDefinitions = get_player_shape_definitions();
// tryAgain tells us whether we made any random choices in the loop. If so, a failed effort results in
// another trip through the loop (hopefully with different random choices :) ).
bool tryAgain = false;
// For safety - don't keep looping if we seem not to be finding good data... eventually, give up as invalid.
int16 theNumberOfTriesLeft = 100;
do {
// We're using up one of our attempts...
theNumberOfTriesLeft--;
// Find the leg action
// We use a local here (instead of using the member directly) so we still which things to pick randomly if we loop.
int16 theLegsAction = mLegsAction;
if(mLegsAction == NONE) {
theLegsAction = local_random() % NUMBER_OF_PLAYER_ACTIONS;
tryAgain = true;
}
// If the user fed us a bad value, stop (with invalid data)
else if(theLegsAction < 0 || theLegsAction >= NUMBER_OF_PLAYER_ACTIONS)
break;
// Find the high-level shape index
uint16 theLegsHighLevelShapeIndex = theShapeDefinitions->legs[theLegsAction];
// Find out how many animation frames there are for the chosen legs
shape_animation_data* theLegsAnimationData = get_shape_animation_data(
BUILD_DESCRIPTOR(theShapeDefinitions->collection, theLegsHighLevelShapeIndex));
// If this failed, either give up or try again
if(theLegsAnimationData == NULL)
continue;
// Find a view for the legs
int16 theLegsView = mLegsView;
if(theLegsView == NONE) {
theLegsView = local_random() % 8;//theLegsAnimationData->number_of_views;
tryAgain = true;
}
else if(theLegsView < 0 || theLegsView >= 8)
break;
// Find an animation frame
int16 theLegsFrame = mLegsFrame;
if(theLegsFrame == NONE) {
theLegsFrame = local_random() % theLegsAnimationData->frames_per_view;
tryAgain = true;
}
else if(theLegsFrame < 0 || theLegsFrame >= theLegsAnimationData->frames_per_view)
break;
// Calculate the low-level shape index index
uint16 theLegsLowLevelShapeIndexIndex = theLegsAnimationData->frames_per_view * theLegsView + theLegsFrame;
// Finally, we can look up the low-level shape index
uint16 theLegsLowLevelShapeIndex = theLegsAnimationData->low_level_shape_indexes[theLegsLowLevelShapeIndexIndex];
// Find a legs color
int16 theLegsColor = mLegsColor;
if(theLegsColor == NONE) {
theLegsColor = local_random() % 8;
tryAgain = true;
}
else if(theLegsColor < 0 || theLegsColor >= 8)
break;
low_level_shape_definition *theLegsLowLevelShape =
get_low_level_shape_definition(theShapeDefinitions->collection, theLegsLowLevelShapeIndex);
if(theLegsLowLevelShape == NULL)
continue;
// Get the shape surfaces for the given collection, CLUT (according to color/team), and low-level shape index.
if (bit_depth == 8) continue;
mLegsSurface = get_shape_surface(theLegsLowLevelShapeIndex,
BUILD_COLLECTION(theShapeDefinitions->collection, theLegsColor), &mLegsData, mLegsBrightness);
if(mLegsSurface == NULL)
continue;
// Fill in rect information
mLegsRect.x = -theLegsLowLevelShape->key_x;
mLegsRect.y = -theLegsLowLevelShape->key_y;
mLegsRect.w = mLegsSurface->w;
mLegsRect.h = mLegsSurface->h;
// We're clear. Copy our temporary variables into the data members.
mLegsAction = theLegsAction;
mLegsView = theLegsView;
mLegsFrame = theLegsFrame;
mLegsColor = theLegsColor;
// We are _valid_. Sweet.
mLegsValid = true;
// Success - get me outta here!
break;
} while(tryAgain && theNumberOfTriesLeft > 0);
// Valid or not, the legs are no longer dirty.
mLegsDirty = false;
}
PixMapHandle get_shape_pixmap(
short shape,
boolean force_copy)
{
OSErr error;
struct collection_definition *collection;
struct low_level_shape_definition *low_level_shape;
struct bitmap_definition *bitmap;
short collection_index, low_level_shape_index, clut_index;
collection_index= GET_COLLECTION(GET_DESCRIPTOR_COLLECTION(shape));
clut_index= GET_COLLECTION_CLUT(GET_DESCRIPTOR_COLLECTION(shape));
low_level_shape_index= GET_DESCRIPTOR_SHAPE(shape);
collection= get_collection_definition(collection_index);
switch (interface_bit_depth)
{
case 8:
/* if the ctSeed of our offscreen pixmap is different from the ctSeed of the world
device then the color environment has changed since the last call to our routine,
and we just HandToHand the deviceÕs ctTable and throw away our old one. */
if ((*(*(*world_device)->gdPMap)->pmTable)->ctSeed!=(*(*hollow_pixmap)->pmTable)->ctSeed)
{
DisposeHandle((Handle)(*hollow_pixmap)->pmTable);
(*hollow_pixmap)->pmTable= (*(*world_device)->gdPMap)->pmTable;
HLock((Handle)hollow_pixmap);
error= HandToHand((Handle *)&(*hollow_pixmap)->pmTable);
HUnlock((Handle)hollow_pixmap);
assert(error==noErr);
/* this is a device color table so we donÕt clear ctFlags (well, it isnÕt a device
color table anymore, but itÕs formatted like one */
}
break;
case 16:
case 32:
if (!hollow_pixmap_color_table)
{
hollow_pixmap_color_table= (CTabHandle) NewHandle(sizeof(ColorTable)+PIXEL8_MAXIMUM_COLORS*sizeof(ColorSpec));
MoveHHi((Handle)hollow_pixmap_color_table);
HLock((Handle)hollow_pixmap_color_table);
assert(hollow_pixmap_color_table);
}
(*hollow_pixmap_color_table)->ctSeed= GetCTSeed();
(*hollow_pixmap_color_table)->ctSize= collection->color_count-NUMBER_OF_PRIVATE_COLORS-1;
(*hollow_pixmap_color_table)->ctFlags= 0;
BlockMove(get_collection_colors(collection_index, clut_index)+NUMBER_OF_PRIVATE_COLORS, &(*hollow_pixmap_color_table)->ctTable,
(collection->color_count-NUMBER_OF_PRIVATE_COLORS)*sizeof(ColorSpec));
(*hollow_pixmap)->pmTable= hollow_pixmap_color_table;
break;
default:
halt();
}
low_level_shape= get_low_level_shape_definition(collection_index, low_level_shape_index);
bitmap= get_bitmap_definition(collection_index, low_level_shape->bitmap_index);
/* setup the pixmap (canÕt wait to change this for Copland) */
SetRect(&(*hollow_pixmap)->bounds, 0, 0, bitmap->width, bitmap->height);
(*hollow_pixmap)->rowBytes= bitmap->width|0x8000;
(*hollow_pixmap)->baseAddr= (Ptr)bitmap->row_addresses[0];
if (bitmap->bytes_per_row==NONE) /* is this a compressed shape? */
{
register pixel8 *read, *write;
register short run_count;
short x;
/* for now all RLE shapes are in column-order */
assert(bitmap->flags&_COLUMN_ORDER_BIT);
/* donÕt overflow the buffer */
assert(bitmap->width*bitmap->height<=HOLLOW_PIXMAP_BUFFER_SIZE);
/* decompress column-order shape into row-order buffer */
for (x=0;x<bitmap->width;x+=1)
{
short bytes_per_row= bitmap->width;
write= hollow_data+x;
read= bitmap->row_addresses[x];
while (run_count= *((short*)read)++)
{
if (run_count<0) while ((run_count+=1)<=0) *write= iBLACK, write+= bytes_per_row; /* fill transparent areas with black */
else while ((run_count-=1)>=0) *write= *read++, write+= bytes_per_row; /* copy shape data */
}
}
(*hollow_pixmap)->baseAddr= (Ptr)hollow_data;
}
else
{
/* if this is a raw, row-order shape then only copy it if weÕve been asked to */
if (force_copy)
{
assert(bitmap->width*bitmap->height<=HOLLOW_PIXMAP_BUFFER_SIZE);
BlockMove(bitmap->row_addresses[0], hollow_data, bitmap->width*bitmap->height);
(*hollow_pixmap)->baseAddr= (Ptr)hollow_data;
}
}
return hollow_pixmap;
}
void
PlayerImage::updateTorsoDrawingInfo() {
// Remove old data, if applicable
if(mTorsoSurface != NULL) {
SDL_FreeSurface(mTorsoSurface);
mTorsoSurface = NULL;
}
if(mTorsoData != NULL) {
free(mTorsoData);
mTorsoData = NULL;
}
mTorsoValid = false;
// Get the player shape definitions
player_shape_definitions* theShapeDefinitions = get_player_shape_definitions();
// tryAgain tells us whether we made any random choices in the loop. If so, a failed effort results in
// another trip through the loop (hopefully with different random choices :) ).
bool tryAgain = false;
// For safety - don't keep looping if we seem not to be finding good data... eventually, give up as invalid.
int16 theNumberOfTriesLeft = 100;
do {
// We're using up one of our attempts...
theNumberOfTriesLeft--;
// Find the torso action
// We use a local here (instead of using the member directly) so we still which things to pick randomly if we loop.
int16 theTorsoAction = mTorsoAction;
if(mTorsoAction == NONE) {
theTorsoAction = local_random() % PLAYER_TORSO_WEAPON_ACTION_COUNT;
tryAgain = true;
}
// If the user fed us a bad value, stop (with invalid data)
else if(theTorsoAction < 0 || theTorsoAction >= PLAYER_TORSO_WEAPON_ACTION_COUNT)
break;
// Find a torso pseudo-weapon
int16 thePseudoWeapon = mPseudoWeapon;
if(mPseudoWeapon == NONE) {
thePseudoWeapon = local_random() % PLAYER_TORSO_SHAPE_COUNT;
tryAgain = true;
}
else if(thePseudoWeapon < 0 || thePseudoWeapon >= PLAYER_TORSO_SHAPE_COUNT)
break;
// Find the high-level shape index
uint16 theTorsoHighLevelShapeIndex;
switch(theTorsoAction) {
case _shape_weapon_firing:
theTorsoHighLevelShapeIndex = theShapeDefinitions->firing_torsos[thePseudoWeapon];
break;
case _shape_weapon_idle:
theTorsoHighLevelShapeIndex = theShapeDefinitions->torsos[thePseudoWeapon];
break;
case _shape_weapon_charging:
theTorsoHighLevelShapeIndex = theShapeDefinitions->charging_torsos[thePseudoWeapon];
break;
default:
// This staves off a compiler warning
theTorsoHighLevelShapeIndex = 0;
assert(false);
}
// Find out how many animation frames there are for the chosen torso
shape_animation_data* theTorsoAnimationData = get_shape_animation_data(
BUILD_DESCRIPTOR(theShapeDefinitions->collection, theTorsoHighLevelShapeIndex));
// If this failed, either give up or try again
if(theTorsoAnimationData == NULL)
continue;
// Find a view for the torso
int16 theTorsoView = mTorsoView;
if(theTorsoView == NONE) {
theTorsoView = local_random() % 8;//theTorsoAnimationData->number_of_views;
tryAgain = true;
}
else if(theTorsoView < 0 || theTorsoView >= 8)
break;
// Find an animation frame
int16 theTorsoFrame = mTorsoFrame;
if(theTorsoFrame == NONE) {
theTorsoFrame = local_random() % theTorsoAnimationData->frames_per_view;
tryAgain = true;
}
else if(theTorsoFrame < 0 || theTorsoFrame >= theTorsoAnimationData->frames_per_view)
break;
// Calculate the low-level shape index index
uint16 theTorsoLowLevelShapeIndexIndex = theTorsoAnimationData->frames_per_view * theTorsoView + theTorsoFrame;
// Finally, we can look up the low-level shape index
uint16 theTorsoLowLevelShapeIndex = theTorsoAnimationData->low_level_shape_indexes[theTorsoLowLevelShapeIndexIndex];
// Find a torso color
int16 theTorsoColor = mTorsoColor;
if(theTorsoColor == NONE) {
theTorsoColor = local_random() % 8;
tryAgain = true;
}
else if(theTorsoColor < 0 || theTorsoColor >= 8)
break;
low_level_shape_definition *theTorsoLowLevelShape =
get_low_level_shape_definition(theShapeDefinitions->collection, theTorsoLowLevelShapeIndex);
if(theTorsoLowLevelShape == NULL)
continue;
// Get the shape surfaces for the given collection, CLUT (according to color/team), and low-level shape index.
if (bit_depth == 8) continue;
mTorsoSurface = get_shape_surface(theTorsoLowLevelShapeIndex,
BUILD_COLLECTION(theShapeDefinitions->collection, theTorsoColor), &mTorsoData, mTorsoBrightness);
// Argh, it failed. Why don't we wait for backup?
if(mTorsoSurface == NULL)
continue;
// Fill in rect information
mTorsoRect.x = -theTorsoLowLevelShape->origin_x;
mTorsoRect.y = -theTorsoLowLevelShape->origin_y;
mTorsoRect.w = mTorsoSurface->w;
mTorsoRect.h = mTorsoSurface->h;
// We're clear. Copy our temporary variables into the data members.
mTorsoAction = theTorsoAction;
mPseudoWeapon = thePseudoWeapon;
mTorsoView = theTorsoView;
mTorsoFrame = theTorsoFrame;
mTorsoColor = theTorsoColor;
// We are _valid_. Sweet.
mTorsoValid = true;
// Success - get me outta here!
break;
} while(tryAgain && theNumberOfTriesLeft > 0);
// Valid or not, the torso is no longer dirty.
mTorsoDirty = false;
}
PixMapHandle editor_get_shape_pixmap(
short shape)
{
OSErr error;
struct collection_definition *collection;
struct low_level_shape_definition *low_level_shape;
struct bitmap_definition *bitmap;
short collection_index, low_level_shape_index, clut_index;
collection_index= GET_COLLECTION(GET_DESCRIPTOR_COLLECTION(shape));
clut_index= GET_COLLECTION_CLUT(GET_DESCRIPTOR_COLLECTION(shape));
low_level_shape_index= GET_DESCRIPTOR_SHAPE(shape);
collection= get_collection_definition(collection_index);
switch (interface_bit_depth)
{
case 8:
/* if the ctSeed of our offscreen pixmap is different from the ctSeed of the world
device then the color environment has changed since the last call to our routine,
and we just HandToHand the deviceÕs ctTable and throw away our old one. */
if ((*(*(*world_device)->gdPMap)->pmTable)->ctSeed!=(*(*hollow_pixmap)->pmTable)->ctSeed)
{
DisposeHandle((Handle)(*hollow_pixmap)->pmTable);
(*hollow_pixmap)->pmTable= (*(*world_device)->gdPMap)->pmTable;
HLock((Handle)hollow_pixmap);
error= HandToHand((Handle *)&(*hollow_pixmap)->pmTable);
HUnlock((Handle)hollow_pixmap);
assert(error==noErr);
/* this is a device color table so we donÕt clear ctFlags (well, it isnÕt a device
color table anymore, but itÕs formatted like one */
}
break;
case 16:
case 32:
if (!hollow_pixmap_color_table)
{
hollow_pixmap_color_table= (CTabHandle) NewHandle(sizeof(ColorTable)+PIXEL8_MAXIMUM_COLORS*sizeof(ColorSpec));
MoveHHi((Handle)hollow_pixmap_color_table);
HLock((Handle)hollow_pixmap_color_table);
assert(hollow_pixmap_color_table);
}
(*hollow_pixmap_color_table)->ctSeed= GetCTSeed();
(*hollow_pixmap_color_table)->ctSize= collection->color_count-NUMBER_OF_PRIVATE_COLORS-1;
(*hollow_pixmap_color_table)->ctFlags= 0;
BlockMove(get_collection_colors(collection_index, clut_index)+NUMBER_OF_PRIVATE_COLORS, &(*hollow_pixmap_color_table)->ctTable,
(collection->color_count-NUMBER_OF_PRIVATE_COLORS)*sizeof(ColorSpec));
(*hollow_pixmap)->pmTable= hollow_pixmap_color_table;
break;
default:
halt();
}
low_level_shape= get_low_level_shape_definition(collection_index, low_level_shape_index);
bitmap= get_bitmap_definition(collection_index, low_level_shape->bitmap_index);
/* setup the pixmap (canÕt wait to change this for Copland) */
SetRect(&(*hollow_pixmap)->bounds, 0, 0, bitmap->width, bitmap->height);
(*hollow_pixmap)->rowBytes= bitmap->width|0x8000;
(*hollow_pixmap)->baseAddr= (Ptr)bitmap->row_addresses[0];
/* Rotate if necessary */
if ((bitmap->flags&_COLUMN_ORDER_BIT) && bitmap->width==128 && bitmap->height==128)
{
static char *buffer= NULL;
if(!buffer)
{
buffer= (char *)malloc(bitmap->width*bitmap->height*sizeof(pixel8));
}
if(buffer)
{
short x, y;
pixel8 *dest= (pixel8 *) buffer;
/* decompress column-order shape into row-order buffer */
for (x=0;x<bitmap->width;x+=1)
{
for(y= 0; y<bitmap->height; y+=1)
{
*dest++= bitmap->row_addresses[y][x];
}
}
(*hollow_pixmap)->baseAddr= buffer;
}
}
return hollow_pixmap;
}