void PasteBuilding( INT32 iMapIndex )
{
BUILDINGLAYOUTNODE *curr;
INT32 iOffset;
if( !gpBuildingLayoutList )
return;
SortBuildingLayout( iMapIndex );
iOffset = iMapIndex - gsBuildingLayoutAnchorGridNo;
curr = gpBuildingLayoutList;
//First time, set the undo gridnos to everything effected.
while( curr )
{
AddToUndoList( curr->sGridNo );
AddToUndoList( curr->sGridNo + iOffset );
curr = curr->next;
}
//Now, paste the building (no smoothing)
curr = gpBuildingLayoutList;
while( curr )
{
PasteMapElementToNewMapElement( curr->sGridNo, curr->sGridNo + iOffset );
curr = curr->next;
}
MarkWorldDirty();
}
void PasteSmartBrokenWall( INT32 iMapIndex )
{
UINT16 usNewWallIndex;
LEVELNODE *pWall;
UINT32 uiTileType;
UINT16 usWallType;
UINT16 usIndex;
UINT16 usWallOrientation;
pWall = GetVerticalWall( iMapIndex );
if( pWall )
{
GetTileType( pWall->usIndex, &uiTileType );
usWallType = (UINT16)uiTileType;
if( uiTileType >= FIRSTDOOR && uiTileType <= LASTDOOR )
{
usWallType = SearchForWallType( iMapIndex );
}
GetWallOrientation( pWall->usIndex, &usWallOrientation );
usIndex = CalcSmartBrokenWallIndex( usWallOrientation );
if( usIndex == 0xffff )
{
AddToUndoList( iMapIndex );
RemoveStruct( iMapIndex, pWall->usIndex );
}
else
{
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usWallType, usIndex, &usNewWallIndex );
ReplaceStructIndex( iMapIndex, pWall->usIndex, usNewWallIndex );
}
}
pWall = GetHorizontalWall( iMapIndex );
if( pWall )
{
GetTileType( pWall->usIndex, &uiTileType );
usWallType = (UINT16)uiTileType;
if( uiTileType >= FIRSTDOOR && uiTileType <= LASTDOOR )
{
//We want to be able to replace doors with a window, however, the doors do not
//contain the wall type, so we have to search for the nearest wall to extract it.
usWallType = SearchForWallType( iMapIndex );
}
GetWallOrientation( pWall->usIndex, &usWallOrientation );
usIndex = CalcSmartBrokenWallIndex( usWallOrientation );
if( usIndex == 0xffff )
{
AddToUndoList( iMapIndex );
RemoveStruct( iMapIndex, pWall->usIndex );
}
else
{
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usWallType, usIndex, &usNewWallIndex );
ReplaceStructIndex( iMapIndex, pWall->usIndex, usNewWallIndex );
}
//Calculate the new graphic for the window type selected.
}
}
void RemoveCaveSectionFromWorld( SGPRect *pSelectRegion )
{
UINT32 top, left, right, bottom, x, y;
UINT32 iMapIndex;
UINT16 usIndex;
UINT8 ubPerimeterValue;
top = pSelectRegion->iTop;
left = pSelectRegion->iLeft;
right = pSelectRegion->iRight;
bottom = pSelectRegion->iBottom;
//Pass 1: Remove all pieces in area
for( y = top; y <= bottom; y++ ) for( x = left; x <= right; x++ )
{
iMapIndex = y * WORLD_COLS + x;
AddToUndoList( iMapIndex );
RemoveAllStructsOfTypeRange( iMapIndex, FIRSTWALL, LASTWALL );
}
//Past 2: Go around outside perimeter and smooth each piece
for( y = top - 1; y <= bottom + 1; y++ ) for( x = left - 1; x <= right + 1; x++ )
{
iMapIndex = y * WORLD_COLS + x;
if( CaveAtGridNo( iMapIndex ) )
{
ubPerimeterValue = CalcNewCavePerimeterValue( iMapIndex );
usIndex = GetCaveTileIndexFromPerimeterValue( ubPerimeterValue );
AddToUndoList( iMapIndex );
if( usIndex != 0xffff )
AddCave( iMapIndex, usIndex );
else
{ //change piece to stalagmite...
RemoveAllStructsOfTypeRange( iMapIndex, FIRSTWALL, LASTWALL );
}
}
}
}
void PasteSmartDoor( INT32 iMapIndex )
{
LEVELNODE *pWall = NULL;
UINT16 usTileIndex;
UINT16 usDoorType;
UINT16 usIndex;
UINT16 usWallOrientation;
if( pWall = GetVerticalWall( iMapIndex ) )
{
GetWallOrientation( pWall->usIndex, &usWallOrientation );
usIndex = CalcSmartDoorIndex( usWallOrientation );
usDoorType = CalcSmartDoorType();
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usDoorType, usIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex, pWall->usIndex, usTileIndex );
}
if( pWall = GetHorizontalWall( iMapIndex ) )
{
GetWallOrientation( pWall->usIndex, &usWallOrientation );
usIndex = CalcSmartDoorIndex( usWallOrientation );
usDoorType = CalcSmartDoorType();
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usDoorType, usIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex, pWall->usIndex, usTileIndex );
}
}
//Specialized function that will delete only the TOP_RIGHT oriented wall in the gridno to the left
//and the TOP_LEFT oriented wall in the gridno up one as well as the other building information at this
//gridno.
void EraseFloorOwnedBuildingPieces( UINT32 iMapIndex )
{
LEVELNODE *pStruct = NULL;
UINT32 uiTileType;
UINT16 usWallOrientation;
if( !gfBasement && !FloorAtGridNo( iMapIndex ) )
{ //We don't have ownership issues if there isn't a floor here.
return;
}
EraseBuilding( iMapIndex );
//FIRST, SEARCH AND DESTROY FOR A LEFT NEIGHBORING TILE WITH A TOP_RIGHT ORIENTED WALL
pStruct = gpWorldLevelData[ iMapIndex - 1 ].pStructHead;
while( pStruct != NULL )
{
if ( pStruct->usIndex != NO_TILE )
{
GetTileType( pStruct->usIndex, &uiTileType );
if ( uiTileType >= FIRSTWALL && uiTileType <= LASTWALL ||
uiTileType >= FIRSTDOOR && uiTileType <= LASTDOOR )
{
GetWallOrientation( pStruct->usIndex, &usWallOrientation );
if( usWallOrientation == INSIDE_TOP_RIGHT || usWallOrientation == OUTSIDE_TOP_RIGHT )
{
AddToUndoList( iMapIndex - 1 );
RemoveStruct( iMapIndex - 1, pStruct->usIndex );
RemoveAllShadowsOfTypeRange( iMapIndex - 1, FIRSTWALL, LASTWALL );
break; //otherwise, it'll crash because pStruct is toast.
}
}
}
pStruct = pStruct->pNext;
}
//FINALLY, SEARCH AND DESTROY FOR A TOP NEIGHBORING TILE WITH A TOP_LEFT ORIENTED WALL
pStruct = gpWorldLevelData[ iMapIndex - WORLD_COLS ].pStructHead;
while( pStruct != NULL )
{
if ( pStruct->usIndex != NO_TILE )
{
GetTileType( pStruct->usIndex, &uiTileType );
if ( uiTileType >= FIRSTWALL && uiTileType <= LASTWALL ||
uiTileType >= FIRSTDOOR && uiTileType <= LASTDOOR )
{
GetWallOrientation( pStruct->usIndex, &usWallOrientation );
if( usWallOrientation == INSIDE_TOP_LEFT || usWallOrientation == OUTSIDE_TOP_LEFT )
{
AddToUndoList( iMapIndex - WORLD_COLS );
RemoveStruct( iMapIndex - WORLD_COLS , pStruct->usIndex );
RemoveAllShadowsOfTypeRange( iMapIndex - WORLD_COLS, FIRSTWALL, LASTWALL );
break; //otherwise, it'll crash because pStruct is toast.
}
}
}
pStruct = pStruct->pNext;
}
}
void EraseRoof( UINT32 iMapIndex )
{
AddToUndoList( iMapIndex );
RemoveAllRoofsOfTypeRange( iMapIndex, FIRSTTEXTURE, LASTITEM );
RemoveAllOnRoofsOfTypeRange( iMapIndex, FIRSTTEXTURE, LASTITEM );
RemoveAllShadowsOfTypeRange( iMapIndex, FIRSTROOF, LASTSLANTROOF );
}
void EraseWalls( UINT32 iMapIndex )
{
AddToUndoList( iMapIndex );
RemoveAllStructsOfTypeRange( iMapIndex, FIRSTTEXTURE, LASTITEM );
RemoveAllShadowsOfTypeRange( iMapIndex, FIRSTWALL, LASTWALL );
RemoveAllShadowsOfTypeRange( iMapIndex, FIRSTDOORSHADOW, LASTDOORSHADOW );
RemoveAllObjectsOfTypeRange( iMapIndex, DEBRISROCKS, LASTDEBRIS );
RemoveAllTopmostsOfTypeRange( iMapIndex, WIREFRAMES, WIREFRAMES );
RemoveAllObjectsOfTypeRange( iMapIndex, DEBRIS2MISC, DEBRIS2MISC );
RemoveAllObjectsOfTypeRange( iMapIndex, ANOTHERDEBRIS, ANOTHERDEBRIS );
}
void BulldozeNature( UINT32 iMapIndex )
{
AddToUndoList( iMapIndex );
RemoveAllStructsOfTypeRange( iMapIndex, FIRSTISTRUCT,LASTISTRUCT );
RemoveAllShadowsOfTypeRange( iMapIndex, FIRSTCLIFFSHADOW, LASTCLIFFSHADOW );
RemoveAllStructsOfTypeRange( iMapIndex, FIRSTOSTRUCT,LASTOSTRUCT ); //outside objects.
RemoveAllShadowsOfTypeRange( iMapIndex, FIRSTSHADOW,LASTSHADOW );
RemoveAllStructsOfTypeRange( iMapIndex, FIRSTROAD, LASTROAD );
RemoveAllObjectsOfTypeRange( iMapIndex, DEBRISROCKS, LASTDEBRIS );
RemoveAllObjectsOfTypeRange( iMapIndex, ANOTHERDEBRIS, ANOTHERDEBRIS );
}
//Road macros vary in size from 3 gridnos to 18 gridnos. Using the anchor gridno based off of the original
//road system, this function will place the new macro (consisting of multiple road pieces in multiple
//gridnos).
void PlaceRoadMacroAtGridNo( INT32 iMapIndex, INT32 iMacroID )
{
INT32 i;
UINT16 usTileIndex;
i = gsRoadMacroStartIndex[ iMacroID ];
while( gRoadMacros[ i ].sMacroID == iMacroID )
{
AddToUndoList( iMapIndex + gRoadMacros[ i ].sOffset );
RemoveAllObjectsOfTypeRange( i, ROADPIECES, ROADPIECES );
GetTileIndexFromTypeSubIndex( ROADPIECES, (UINT16)(i+1) , &usTileIndex );
AddObjectToHead( iMapIndex + gRoadMacros[ i ].sOffset, usTileIndex );
i++;
}
}
//Given a gridno, it will erase the current roof, and calculate the new roof piece based on the
//wall orientions giving priority to the top and left walls before anything else.
//NOTE: passing NULL for usRoofType will force the function to calculate the nearest roof type,
// and use that for the new roof. This is needed when erasing parts of multiple buildings simultaneously.
void RebuildRoof( UINT32 iMapIndex, UINT16 usRoofType )
{
UINT16 usRoofIndex, usTileIndex;
BOOLEAN fTop, fBottom, fLeft, fRight;
if( !usRoofType )
{
usRoofType = SearchForRoofType( iMapIndex );
}
if( usRoofType == 0xffff )
return; //no roof type around, so don't draw one.
//Analyse the mapindex for walls and set the flags.
//NOTE: There is no support for more than 2 side on a roof, so if there is, draw TOPLEFT
AddToUndoList( iMapIndex );
EraseRoof( iMapIndex );
fTop = GetHorizontalWall( iMapIndex - WORLD_COLS ) ? TRUE : FALSE;
fLeft = GetVerticalWall( iMapIndex - 1 ) ? TRUE : FALSE;
fBottom = GetHorizontalWall( iMapIndex ) ? TRUE : FALSE;
fRight = GetVerticalWall( iMapIndex ) ? TRUE : FALSE;
if( fTop && fLeft ) usRoofIndex = TOPLEFT_ROOF_INDEX;
else if( fTop && fRight) usRoofIndex = TOPRIGHT_ROOF_INDEX;
else if( fBottom && fLeft ) usRoofIndex = BOTTOMLEFT_ROOF_INDEX;
else if( fBottom && fRight ) usRoofIndex = BOTTOMRIGHT_ROOF_INDEX;
else if( fTop ) usRoofIndex = TOP_ROOF_INDEX;
else if( fBottom ) usRoofIndex = BOTTOM_ROOF_INDEX;
else if( fLeft ) usRoofIndex = LEFT_ROOF_INDEX;
else if( fRight ) usRoofIndex = RIGHT_ROOF_INDEX;
else usRoofIndex = CENTER_ROOF_BASE_INDEX + ( rand() % CENTER_ROOF_VARIANTS );
GetTileIndexFromTypeSubIndex( usRoofType, usRoofIndex, &usTileIndex );
AddRoofToHead( iMapIndex, usTileIndex );
//if the editor view roofs is off, then the new roofs need to be hidden.
if( !fBuildingShowRoofs )
{
HideStructOfGivenType( iMapIndex, usRoofType, TRUE );
}
}
void EraseFloor( UINT32 iMapIndex )
{
AddToUndoList( iMapIndex );
RemoveAllLandsOfTypeRange( iMapIndex, FIRSTFLOOR, LASTFLOOR );
}
//From a given gridNo and perspective (wallpiece), it will calculate the new piece, and
//where to place it as well as handle the special cases.
//NOTE: Placing top and left pieces are placed relative to the gridno, and the gridNo will
// shift accordingly to place the piece. Pretend you are the floor, and you want to place a piece to
// the left. You pass your position, and INTERIOR_LEFT, with interior meaning from the inside of a
// building. If you were outside the building, you would call EXTERIOR_LEFT. The left tile will be
// placed on gridNo - 1! Up tiles will be placed on gridNo - 160.
//NOTE: Passing NULL for usWallType will force it to calculate the closest existing wall type, and
// use that for building this new wall. It is necessary for restructuring a building, but not for
// adding on to an existing building, where the type is already known.
void BuildWallPiece( UINT32 iMapIndex, UINT8 ubWallPiece, UINT16 usWallType )
{
INT16 sIndex;
UINT16 usTileIndex;
UINT16 ubWallClass;
LEVELNODE *pStruct;
if( !usWallType )
{
usWallType = SearchForWallType( iMapIndex );
}
switch( ubWallPiece )
{
case EXTERIOR_TOP:
iMapIndex -= WORLD_COLS;
//exterior bottom left corner generated
if ( !gfBasement && GetVerticalWall( iMapIndex - 1) && !GetVerticalWall( iMapIndex + WORLD_COLS - 1) )
{ //Special case where a shadow has to be created as it now is a bottom corner and
//must contribute to the bottom shadow.
AddToUndoList( iMapIndex - 1 );
GetTileIndexFromTypeSubIndex( usWallType, INTERIOR_BOTTOMEND_SHADOW_INDEX, &usTileIndex );
AddExclusiveShadow( iMapIndex - 1, usTileIndex );
}
if ( pStruct = GetVerticalWall( iMapIndex ) ) //right corner
{ //Special case where placing the new wall will generate a corner to the right, so replace
//the vertical piece with a bottomend.
sIndex = PickAWallPiece( EXTERIOR_BOTTOMEND );
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usWallType, sIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex, pStruct->usIndex, usTileIndex );
}
ubWallClass = EXTERIOR_L;
if( !gfBasement )
{
//All exterior_l walls have shadows.
GetTileIndexFromTypeSubIndex( usWallType, EXTERIOR_L_SHADOW_INDEX, &usTileIndex );
AddExclusiveShadow( iMapIndex, usTileIndex );
}
break;
case EXTERIOR_BOTTOM:
ubWallClass = INTERIOR_L;
if( (pStruct = GetVerticalWall( iMapIndex + WORLD_COLS - 1 )) && !GetVerticalWall( iMapIndex - 1) )
{
sIndex = PickAWallPiece( INTERIOR_EXTENDED );
AddToUndoList( iMapIndex + WORLD_COLS - 1 );
GetTileIndexFromTypeSubIndex( usWallType, sIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex + WORLD_COLS - 1, pStruct->usIndex, usTileIndex );
}
break;
case EXTERIOR_LEFT:
iMapIndex--;
ubWallClass = EXTERIOR_R;
if( GetHorizontalWall( iMapIndex ) )
{ //Special case where placing the new wall will generate a corner. This piece
//becomes an exterior bottomend, but nothing else is effected.
ubWallClass = EXTERIOR_BOTTOMEND;
}
if( GetHorizontalWall( iMapIndex - WORLD_COLS + 1 ) )
{
if( ubWallClass == EXTERIOR_BOTTOMEND )
ubWallClass = EXTERIOR_EXTENDED_BOTTOMEND;
else
ubWallClass = EXTERIOR_EXTENDED;
}
break;
case EXTERIOR_RIGHT:
ubWallClass = INTERIOR_R;
if( GetHorizontalWall( iMapIndex - WORLD_COLS + 1 ) && !GetHorizontalWall( iMapIndex - WORLD_COLS ) )
{
ubWallClass = INTERIOR_EXTENDED;
}
else if( GetHorizontalWall( iMapIndex ) && !GetVerticalWall( iMapIndex + WORLD_COLS ) )
{
ubWallClass = INTERIOR_BOTTOMEND;
}
break;
case INTERIOR_TOP:
iMapIndex -= WORLD_COLS;
ubWallClass = INTERIOR_L;
//check for a lower left corner.
if( pStruct = GetVerticalWall( iMapIndex + WORLD_COLS - 1 ) )
{ //Replace the piece with an extended piece.
sIndex = PickAWallPiece( INTERIOR_EXTENDED );
AddToUndoList( iMapIndex + WORLD_COLS - 1 );
GetTileIndexFromTypeSubIndex( usWallType, sIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex + WORLD_COLS - 1, pStruct->usIndex, usTileIndex );
//NOTE: Not yet checking for interior extended bottomend!
}
if( pStruct = GetVerticalWall( iMapIndex ) )
{
sIndex = PickAWallPiece( INTERIOR_BOTTOMEND );
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usWallType, sIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex, pStruct->usIndex, usTileIndex );
}
break;
case INTERIOR_BOTTOM:
ubWallClass = EXTERIOR_L;
if( pStruct = GetVerticalWall( iMapIndex ) ) //right corner
{ //Special case where placing the new wall will generate a corner to the right, so replace
//the vertical piece with a bottomend.
sIndex = PickAWallPiece( EXTERIOR_BOTTOMEND );
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usWallType, sIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex, pStruct->usIndex, usTileIndex );
}
if( (pStruct = GetVerticalWall( iMapIndex + WORLD_COLS - 1 )) && !GetVerticalWall( iMapIndex - 1) )
{
sIndex = PickAWallPiece( EXTERIOR_EXTENDED );
AddToUndoList( iMapIndex + WORLD_COLS - 1 );
GetTileIndexFromTypeSubIndex( usWallType, sIndex, &usTileIndex );
ReplaceStructIndex( iMapIndex + WORLD_COLS - 1, pStruct->usIndex, usTileIndex );
}
if( !gfBasement )
{
//All exterior_l walls have shadows.
GetTileIndexFromTypeSubIndex( usWallType, EXTERIOR_L_SHADOW_INDEX, &usTileIndex );
AddExclusiveShadow( iMapIndex, usTileIndex );
}
break;
case INTERIOR_LEFT:
iMapIndex--;
ubWallClass = INTERIOR_R;
if( GetHorizontalWall( iMapIndex ) )
{
ubWallClass = INTERIOR_BOTTOMEND;
}
if( !gfBasement && GetHorizontalWall( iMapIndex + 1 ) )
{
AddToUndoList( iMapIndex );
GetTileIndexFromTypeSubIndex( usWallType, INTERIOR_BOTTOMEND_SHADOW_INDEX, &usTileIndex );
AddExclusiveShadow( iMapIndex, usTileIndex );
}
if( GetHorizontalWall( iMapIndex - WORLD_COLS + 1 ) )
{
if( ubWallClass == INTERIOR_BOTTOMEND )
ubWallClass = INTERIOR_EXTENDED_BOTTOMEND;
else
ubWallClass = INTERIOR_EXTENDED;
}
break;
case INTERIOR_RIGHT:
ubWallClass = EXTERIOR_R;
if( GetHorizontalWall( iMapIndex ) )
{ //Special case where placing the new wall will generate a corner. This piece
//becomes an exterior bottomend, but nothing else is effected.
ubWallClass = EXTERIOR_BOTTOMEND;
}
if( GetHorizontalWall( iMapIndex - WORLD_COLS + 1 ) )
{
if( ubWallClass == EXTERIOR_BOTTOMEND )
ubWallClass = EXTERIOR_EXTENDED_BOTTOMEND;
else
ubWallClass = EXTERIOR_EXTENDED;
}
if( !gfBasement && GetHorizontalWall( iMapIndex + 1 ) && !GetHorizontalWall( iMapIndex )
&& !FloorAtGridNo( iMapIndex + WORLD_COLS ) )
{
GetTileIndexFromTypeSubIndex( usWallType, INTERIOR_BOTTOMEND_SHADOW_INDEX, &usTileIndex );
AddExclusiveShadow( iMapIndex, usTileIndex );
}
break;
}
sIndex = PickAWallPiece( ubWallClass );
GetTileIndexFromTypeSubIndex( usWallType, sIndex, &usTileIndex );
AddToUndoList( iMapIndex );
AddWallToStructLayer( iMapIndex, usTileIndex, FALSE );
}
void BuildSlantRoof( INT32 iLeft, INT32 iTop, INT32 iRight, INT32 iBottom, UINT16 usWallType, UINT16 usRoofType, BOOLEAN fVertical )
{
INT32 i;
UINT16 usTileIndex;
INT32 iMapIndex;
if( fVertical )
{
iMapIndex = iBottom * WORLD_COLS + iLeft;
//This happens to be the only mapindex that needs to be backed up. The rest have already been
//done because of the building code before this.
AddToUndoList( iMapIndex + 8 );
//Add the closest viewable pieces. There are two aframe walls pieces, and extended aframe roof pieces.
GetTileIndexFromTypeSubIndex( usWallType, VWALL_LEFT, &usTileIndex );
AddRoofToHead( iMapIndex + 4, usTileIndex );
GetTileIndexFromTypeSubIndex( usWallType, VWALL_RIGHT, &usTileIndex );
AddRoofToHead( iMapIndex + 8, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THICK_LEFT, &usTileIndex );
AddRoofToHead( iMapIndex + 3, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THICK_RIGHT, &usTileIndex );
AddRoofToHead( iMapIndex + 7, usTileIndex );
for( i = iBottom - 1; i > iTop; i-- )
{
iMapIndex -= WORLD_COLS;
GetTileIndexFromTypeSubIndex( usRoofType, THIN_LEFT, &usTileIndex );
AddRoofToHead( iMapIndex + 3, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THIN_RIGHT, &usTileIndex );
AddRoofToHead( iMapIndex + 7, usTileIndex );
}
iMapIndex -= WORLD_COLS;
GetTileIndexFromTypeSubIndex( usRoofType, THICK_LEFT, &usTileIndex );
AddRoofToHead( iMapIndex + 3, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THICK_RIGHT, &usTileIndex );
AddRoofToHead( iMapIndex + 7, usTileIndex );
}
else
{
iMapIndex = iTop * WORLD_COLS + iRight;
//This happens to be the only mapindex that needs to be backed up. The rest have already been
//done because of the building code before this.
AddToUndoList( iMapIndex + 8*WORLD_COLS );
//Add the closest viewable pieces. There are two aframe walls pieces, and extended aframe roof pieces.
GetTileIndexFromTypeSubIndex( usWallType, HWALL_LEFT, &usTileIndex );
AddRoofToHead( iMapIndex + 4*WORLD_COLS, usTileIndex );
GetTileIndexFromTypeSubIndex( usWallType, HWALL_RIGHT, &usTileIndex );
AddRoofToHead( iMapIndex + 8*WORLD_COLS, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THICK_TOP, &usTileIndex );
AddRoofToHead( iMapIndex + 3*WORLD_COLS, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THICK_BOTTOM, &usTileIndex );
AddRoofToHead( iMapIndex + 7*WORLD_COLS, usTileIndex );
for( i = iRight - 1; i > iLeft; i-- )
{
iMapIndex--;
GetTileIndexFromTypeSubIndex( usRoofType, THIN_TOP, &usTileIndex );
AddRoofToHead( iMapIndex + 3*WORLD_COLS, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THIN_BOTTOM, &usTileIndex );
AddRoofToHead( iMapIndex + 7*WORLD_COLS, usTileIndex );
}
iMapIndex--;
GetTileIndexFromTypeSubIndex( usRoofType, THICK_TOP, &usTileIndex );
AddRoofToHead( iMapIndex + 3*WORLD_COLS, usTileIndex );
GetTileIndexFromTypeSubIndex( usRoofType, THICK_BOTTOM, &usTileIndex );
AddRoofToHead( iMapIndex + 7*WORLD_COLS, usTileIndex );
}
}
