void Pathway::load(const Tilemap& tmap, const VariantMap& stream )
{
if( stream.empty() )
{
return;
}
VARIANT_LOAD_ANY_D( _d, startPos, stream )
VARIANT_LOAD_ANY_D( _d, endPos, stream )
VariantList vmTiles = stream.get( literals::tiles ).toList();
foreach( it, vmTiles )
{
_d->tiles.push_back( const_cast<Tile*>( &tmap.at( it->toTilePos() )) );
}
void Pathway::setNextDirection( const Tilemap& tmap, Direction direction)
{
switch (direction)
{
case direction::north :
_d->endPos += TilePos( 0, 1 );
break;
case direction::northEast :
_d->endPos += TilePos( 1, 1 );
break;
case direction::east :
_d->endPos += TilePos( 1, 0 );
break;
case direction::southEast :
_d->endPos += TilePos( 1, -1 );
break;
case direction::south :
_d->endPos += TilePos( 0, -1 );
break;
case direction::southWest :
_d->endPos += TilePos( -1, -1 );
break;
case direction::west :
_d->endPos += TilePos( -1, 0 );
break;
case direction::northWest :
_d->endPos += TilePos( -1, 1 );
break;
default:
_d->endPos += TilePos( 0, 1 );
break;
Logger::warning( "Unexpected Direction:%d", direction);
break;
}
if( tmap.isInside( _d->endPos ) )
{
_d->tiles.push_back( const_cast<Tile*>( &tmap.at( _d->endPos )) );
}
}
void GameLoader::Impl::initEntryExitTile( const TilePos& tlPos, Tilemap& tileMap, const unsigned int picIdStart, bool exit )
{
unsigned int idOffset = 0;
TilePos tlOffset;
if( tlPos.getI() == 0 || tlPos.getI() == tileMap.getSize() - 1 )
{
tlOffset = TilePos( 0, 1 );
idOffset = (tlPos.getI() == 0 ? 1 : 3 );
}
else if( tlPos.getJ() == 0 || tlPos.getJ() == tileMap.getSize() - 1 )
{
tlOffset = TilePos( 1, 0 );
idOffset = (tlPos.getJ() == 0 ? 2 : 0 );
}
Tile& signTile = tileMap.at( tlPos + tlOffset );
StringHelper::debug( 0xff, "(%d, %d)", tlPos.getI(), tlPos.getJ() );
StringHelper::debug( 0xff, "(%d, %d)", tlOffset.getI(), tlOffset.getJ() );
signTile.setPicture( ResourceGroup::land3a, picIdStart + idOffset );
signTile.setFlag( Tile::tlRock, true );
}
void Builder::paintTileWallCorners(Tilemap& tileMap, uint32_t tileY, uint32_t tileX,
const TileBrush& brush)
{
uint16_t cornerMask = kTileDirection_N | kTileDirection_W |
kTileDirection_S | kTileDirection_E;
Tile& thisTile = tileMap.at(tileY, tileX);
if (thisTile.wall)
{
// this tile already has a wall - no need to run tests
return;
}
//printf("at (%u,%u) => ", tileX, tileY);
uint16_t wallRoleFlags = 0;
if (tileY > 0)
{
const Tile& north = tileMap.at(tileY-1, tileX);
//printf("north:[%u,%u], ", north.floor, north.wall);
if (!tileWallsEqual(north, kTileDirection_W, brush.tileClassId) &&
!tileWallsEqual(north, kTileDirection_E, brush.tileClassId) &&
!tileWallsEqual(north, kTileDirection_NW, brush.tileClassId) &&
!tileWallsEqual(north, kTileDirection_NE, brush.tileClassId))
{
cornerMask &= ~(kTileDirection_N);
}
}
if (tileX > 0)
{
const Tile& west = tileMap.at(tileY, tileX-1);
//printf("west:[%u,%u], ", west.floor, west.wall);
if (!tileWallsEqual(west, kTileDirection_N, brush.tileClassId) &&
!tileWallsEqual(west, kTileDirection_S, brush.tileClassId) &&
!tileWallsEqual(west, kTileDirection_NW, brush.tileClassId) &&
!tileWallsEqual(west, kTileDirection_SW, brush.tileClassId))
{
cornerMask &= ~(kTileDirection_W);
}
}
if (tileY < tileMap.rowCount()-1)
{
const Tile& south = tileMap.at(tileY+1, tileX);
//printf("south:[%u,%u], ", south.floor, south.wall);
if (!tileWallsEqual(south, kTileDirection_W, brush.tileClassId) &&
!tileWallsEqual(south, kTileDirection_E, brush.tileClassId) &&
!tileWallsEqual(south, kTileDirection_SW, brush.tileClassId) &&
!tileWallsEqual(south, kTileDirection_SE, brush.tileClassId))
{
cornerMask &= ~(kTileDirection_S);
}
}
if (tileX < tileMap.columnCount()-1)
{
const Tile& east = tileMap.at(tileY, tileX+1);
//printf("east:[%u,%u], ", east.floor, east.wall);
if (!tileWallsEqual(east, kTileDirection_S, brush.tileClassId) &&
!tileWallsEqual(east, kTileDirection_N, brush.tileClassId) &&
!tileWallsEqual(east, kTileDirection_NE, brush.tileClassId) &&
!tileWallsEqual(east, kTileDirection_SE, brush.tileClassId))
{
cornerMask &= ~(kTileDirection_E);
}
}
if (cornerMask & kTileDirection_W)
{
if (cornerMask & kTileDirection_N)
wallRoleFlags |= kTileDirection_NW;
else if (cornerMask & kTileDirection_S)
wallRoleFlags |= kTileDirection_SW;
}
if (!wallRoleFlags && (cornerMask & kTileDirection_N))
{
if (cornerMask & kTileDirection_E)
wallRoleFlags |= kTileDirection_NE;
}
if (!wallRoleFlags && (cornerMask & kTileDirection_E))
{
if (cornerMask & kTileDirection_S)
wallRoleFlags |= kTileDirection_SE;
}
//printf("cornerFlags, wallRoleFlags (%04x,%04x)\n",
// cornerMask, wallRoleFlags);
wallRoleFlags |= (kTileRole_Wall+kTileRole_Corner);
TileHandle wallTileHandle =
_tileTemplates.tileHandleFromDescriptor(brush.tileCategoryId,
brush.tileClassId,
wallRoleFlags);
thisTile.wall = wallTileHandle;
}
void Builder::paintTileWalls(Tilemap& tileMap, uint32_t tileY, uint32_t tileX,
const TileBrush& brush)
{
const TileTemplate& thisFloorTemplate =
_tileTemplates.tile(tileMap.at(tileY, tileX).floor);
// calculate wall masks, which are used to determine what wall tiles
// to display.
uint16_t wallMask = kTileDirection_N | kTileDirection_E |
kTileDirection_W | kTileDirection_S;
if (tileY > 0 &&
tileFloorsClassIdEqual(tileMap.at(tileY-1, tileX), thisFloorTemplate.classId))
{
wallMask &= ~(kTileDirection_N);
}
if (tileX > 0 &&
tileFloorsClassIdEqual(tileMap.at(tileY, tileX-1), thisFloorTemplate.classId))
{
wallMask &= ~(kTileDirection_W);
}
if (tileY < tileMap.rowCount()-1 &&
tileFloorsClassIdEqual(tileMap.at(tileY+1, tileX), thisFloorTemplate.classId))
{
wallMask &= ~(kTileDirection_S);
}
if (tileX < tileMap.columnCount()-1 &&
tileFloorsClassIdEqual(tileMap.at(tileY, tileX+1), thisFloorTemplate.classId))
{
wallMask &= ~(kTileDirection_E);
}
uint16_t wallRoleFlags = 0;
if (wallMask)
{
if (wallMask & kTileDirection_W)
{
if (wallMask & kTileDirection_N)
wallRoleFlags |= kTileDirection_NW;
else if (wallMask & kTileDirection_S)
wallRoleFlags |= kTileDirection_SW;
else
wallRoleFlags |= kTileDirection_W;
}
if (!wallRoleFlags && (wallMask & kTileDirection_N))
{
// we've already evaluated for West, so only need to eval East
if (wallMask & kTileDirection_E)
wallRoleFlags |= kTileDirection_NE;
else
wallRoleFlags |= kTileDirection_N;
}
if (!wallRoleFlags && (wallMask & kTileDirection_E))
{
// we've already evaluated North, so only care about South
if (wallMask & kTileDirection_S)
wallRoleFlags |= kTileDirection_SE;
else
wallRoleFlags |= kTileDirection_E;
}
if (!wallRoleFlags && (wallMask & kTileDirection_S))
{
// we've already evaluated East and West, so...
wallRoleFlags |= kTileDirection_S;
}
wallRoleFlags |= kTileRole_Wall;
}
TileHandle wallTileHandle =
_tileTemplates.tileHandleFromDescriptor(brush.tileCategoryId,
brush.tileClassId,
wallRoleFlags);
Tile& thisTile = tileMap.at(tileY, tileX);
thisTile.wall = wallTileHandle;
}
