C++ TilePos函数代码示例

CartSupplier::CartSupplier( CityPtr city ) : _d( new Impl )
{
   _walkerGraphic = WG_PUSHER;
   _walkerType = WT_CART_PUSHER;
   _d->storageBuildingPos = TilePos( -1, -1 );
   _d->baseBuildingPos = TilePos( -1, -1 );
   _d->maxDistance = 25;
   _d->city = city;
}

CartSupplier::CartSupplier( CityPtr city )
  : Walker( city ), _d( new Impl )
{
  _setGraphic( WG_PUSHER );
  _setType( WT_CART_PUSHER );

  _d->storageBuildingPos = TilePos( -1, -1 );
  _d->baseBuildingPos = TilePos( -1, -1 );
  _d->maxDistance = 25;
  _d->city = city;

  setName( NameGenerator::rand( NameGenerator::male ) );
}

void Construction::_updateDesirabilityInfluence( bool onBuild )
{
  City &city = Scenario::instance().getCity();
  Tilemap &tilemap = city.getTilemap();

  PtrTilesList desirabilityArea = tilemap.getFilledRectangle( getTile().getIJ() - TilePos( 2, 2 ), 
    getTile().getIJ() + TilePos( 2 + getSize(), 2 + getSize() ) );

  int mul = (onBuild ? 1 : -1);
  for( PtrTilesList::iterator it=desirabilityArea.begin(); it != desirabilityArea.end(); it++ )
  {
    (*it)->get_terrain().appendDesirability( mul * getDesirabilityInfluence() );
  }
}

void Warehouse::init()
{
  _fgPictures[0] = &Picture::load(ResourceGroup::warehouse, 1);
  _fgPictures[1] = &Picture::load(ResourceGroup::warehouse, 18);
  _fgPictures[2] = _animation.getCurrentPicture();
  _fgPictures[3] = _animFlag.getCurrentPicture();

  // add subTiles in Z-order (from far to near)
  _subTiles.clear();
  _subTiles.push_back( WarehouseTile( TilePos( 1, 2 ) ));
  _subTiles.push_back( WarehouseTile( TilePos( 0, 1 ) ));
  _subTiles.push_back( WarehouseTile( TilePos( 2, 2 ) ));
  _subTiles.push_back( WarehouseTile( TilePos( 1, 1 ) ));
  _subTiles.push_back( WarehouseTile( TilePos( 0, 0 ) ));
  _subTiles.push_back( WarehouseTile( TilePos( 2, 1 ) ));
  _subTiles.push_back( WarehouseTile( TilePos( 1, 0 ) ));
  _subTiles.push_back( WarehouseTile( TilePos( 2, 0 ) ));

  for (unsigned int n = 0; n<_subTiles.size(); ++n)
  {
     _fgPictures[n+4] = &_subTiles[n]._picture;
  }

  _goodStore.init(*this);

  GoodStock stock;
  stock._goodType = G_POTTERY;
  stock._currentQty = 300;
  _goodStore.store(stock, 300);

  computePictures();
}

void BuildingPrefecture::deliverService()
{
  if( getWorkers() > 0 && getWalkerList().size() == 0 )
  {
    bool fireDetect = _fireDetect.getI() >= 0;
    WalkerPrefectPtr walker = WalkerPrefect::create( Scenario::instance().getCity() );
    walker->setMaxDistance( 26 );

    //bool patrol = true;
    if( fireDetect )
    {
      PathWay pathway;
      TilePos startPos = _accessRoads.front()->getIJ();
      bool pathFounded = Pathfinder::getInstance().getPath( startPos, _fireDetect, pathway, false, Size( 0 ) );
      //patrol = !pathFounded;

      if( pathFounded )
      {
        walker->setPathWay( pathway );
        walker->setIJ( pathway.getOrigin().getIJ() );
      }

      _fireDetect = TilePos( -1, -1 );
    }
    
    walker->send2City( BuildingPrefecturePtr( this ), fireDetect ? 200 : 0 );

    addWalker( walker.as<Walker>() );
  }
}

void TileOverlay::build( CityPtr city, const TilePos& pos )
{
  Tilemap &tilemap = city->getTilemap();

  _d->city = city;
  _d->masterTile = &tilemap.at( pos );

  for (int dj = 0; dj < _d->size.getWidth(); ++dj)
  {
    for (int di = 0; di < _d->size.getHeight(); ++di)
    {
      Tile& tile = tilemap.at( pos + TilePos( di, dj ) );
      tile.setMasterTile( _d->masterTile );
      tile.setPicture( &_d->picture );

      if( tile.getOverlay().isValid() && tile.getOverlay() != this )
      {
        tile.getOverlay()->deleteLater();
      }

      tile.setOverlay( this );
      initTerrain( tile );
    }
  }
}

void WDT::ReadTileTable()
{
    Chunk* chunk = Data->GetChunkByName("MAIN");
    if (!chunk)
        return;
    IsValid = true;
    FILE* stream = chunk->GetStream();
    for (int y = 0; y < 64; ++y)
    {
        for (int x = 0; x < 64; ++x)
        {
            const uint32 hasTileFlag = 0x1;
            uint32 flags;
            uint32 discard;
            int count = 0;
            count += fread(&flags, sizeof(uint32), 1, stream);
            count += fread(&discard, sizeof(uint32), 1, stream);

            if (count != 2)
                printf("WDT::ReadTileTable: Failed to read some data expected 2, read %d\n", count);

            if (flags & hasTileFlag)
                TileTable.push_back(TilePos(x, y));

        }
    }
}

 int getGScore(AStarPoint* p)
 { 
   int offset = p->tile->get_terrain().isRoad() ? -5 : +10;
   TilePos pos = tile ? tile->getIJ() : TilePos( 0, 0 ); 
   TilePos otherPos = p->tile->getIJ();
   return p->g + ((pos.getI() == otherPos.getI() || pos.getJ() == otherPos.getJ()) ? 10 : 14) + offset;
 }

/* INCORRECT! */
bool Wharf::canBuild(const TilePos& pos ) const
{
  bool is_constructible = Construction::canBuild( pos );

  // We can build wharf only on straight border of water and land
  //
  //   ?WW? ???? ???? ????
  //   ?XX? WXX? ?XXW ?XX?
  //   ?XX? WXX? ?XXW ?XX?
  //   ???? ???? ???? ?WW?
  //

  bool bNorth = true;
  bool bSouth = true;
  bool bWest  = true;
  bool bEast  = true;
   
  Tilemap& tilemap = Scenario::instance().getCity().getTilemap();
   
  std::list<Tile*> rect = tilemap.getRectangle( pos + TilePos( -1, -1 ), Size( _size+2 ), false);
  for (std::list<Tile*>::iterator itTiles = rect.begin(); itTiles != rect.end(); ++itTiles)
  {
    Tile &tile = **itTiles;
    std::cout << tile.getI() << " " << tile.getJ() << "  " << pos.getI() << " " << pos.getJ() << std::endl;
      
     // if (tiles.get_terrain().isWater())
      
     if (tile.getJ() > (pos.getJ() + _size -1) && !tile.get_terrain().isWater()) {  bNorth = false; }
     if (tile.getJ() < pos.getJ() && !tile.get_terrain().isWater())              {  bSouth = false; }
     if (tile.getI() > (pos.getI() + _size -1) && !tile.get_terrain().isWater()) {  bEast = false;  }
     if (tile.getI() < pos.getI() && !tile.get_terrain().isWater())              {  bWest = false;  }      
   }

   return (is_constructible && (bNorth || bSouth || bEast || bWest));
}

TilePosList TileGrid::nearestNeighbors(TilePos origin)
{
   TilePosList toReturn;
   toReturn.reserve(8);

   auto mods = { -1, 0, 1 };

   for (auto &x : mods)
   {
      for (auto &y : mods)
      {
         if (x || y)
         {
            auto pos = TilePos(origin.x + x, origin.y + y);

            if (isTilePosValid(pos))
            {
               toReturn.push_back(pos);
            }
         }
      }
   }

   return toReturn;
}

void Fishery::timeStep(const unsigned int time )
{  
  if( !game::Date::isMonthChanged() )
    return;

  if( _d->places.empty() )
  {
    _d->places = city::statistic::getWalkers<FishPlace>( _city(), walker::fishPlace, TilePos(-1, -1) );
  }

  while( _d->places.size() < _d->maxFishPlace )
  {
    FishPlacePtr fishplace = FishPlace::create( _city() );
    TilePos travelingPoint = _city()->borderInfo().boatExit;
    if( !_d->locations.empty() )
    {
      travelingPoint = _d->locations.size() > 1
                         ? _d->locations[ math::random( _d->locations.size() ) ]
                         : _d->locations.front();
    }

    fishplace->send2city( _city()->borderInfo().boatEntry, travelingPoint );

    if( fishplace->isDeleted() )
    {
      _d->nFailed++;
      return;
    }

    _d->places.push_back( ptr_cast<FishPlace>( fishplace ) );
  }

  utils::eraseDeletedElements( _d->places );
}

std::list<Tile*> Tilemap::getRectangle( const TilePos& start, const TilePos& stop, const bool corners /*= true*/ )
{
    std::list<Tile*> res;

    int delta_corners = 0;
    if (! corners)
    {
        delta_corners = 1;
    }

    /*Rect maxRect( 0, 0, _size, _size );
    Rect rect( start.getI()+delta_corners, start.getJ()+delta_corners, 
               stop.getI()-delta_corners, stop.getJ()-delta_corners );

    rect.constrainTo( maxRect );
    for( int i=rect.getLeft(); i < rect.getRight(); i++ )
        for( int j=rect.getTop(); j < rect.getBottom(); j++ )
            ret.push_back( &at( TilePos( i, j ) ) );
    */
    for(int i = start.getI()+delta_corners; i <= stop.getI()-delta_corners; ++i)
    {
        if (is_inside( TilePos( i, start.getJ() ) ))
        {
            res.push_back( &at(i, start.getJ() ));
        }

        if (is_inside( TilePos( i, stop.getJ() ) ))
        {
            res.push_back( &at( i, stop.getJ() ));
        }
    }

    for (int j = start.getJ()+1; j <= stop.getJ()-1; ++j)  // corners have been handled already
    {
        if (is_inside( TilePos( start.getI(), j ) ))
        {
            res.push_back(&at(start.getI(), j));
        }

        if (is_inside( TilePos( stop.getI(), j ) ))
        {
            res.push_back(&at(stop.getI(), j));
        }
    }

    return res;
}

std::list<Tile*> Tilemap::getFilledRectangle(const TilePos& start, const TilePos& stop )
{
   std::list<Tile*> res;

   for (int i = start.getI(); i <= stop.getI(); ++i)
   {
      for (int j = start.getJ(); j <= stop.getJ(); ++j)
      {
         if( is_inside( TilePos( i, j ) ))
         {
            res.push_back(&at( TilePos( i, j ) ) );
         }
      }
   }

   return res;
}

Prefecture::Prefecture() : ServiceBuilding(Service::prefect, constants::building::prefecture, Size(1))
{
  _fireDetect = TilePos( -1, -1 );
  setPicture( ResourceGroup::security, 1 );
  
  _getAnimation().load( ResourceGroup::security, 2, 10);
  _getAnimation().setDelay( 4 );
  _getAnimation().setOffset( Point( 20, 36 ) );
  _getFgPictures().resize(1);
}

Prefecture::Prefecture() : ServiceBuilding(Service::S_PREFECT, B_PREFECTURE, Size(1))
{
  _fireDetect = TilePos( -1, -1 );
  setPicture( Picture::load( ResourceGroup::security, 1 ) );
  
  _getAnimation().load( ResourceGroup::security, 2, 10);
  _getAnimation().setFrameDelay( 4 );
  _getAnimation().setOffset( Point( 20, 36 ) );
  _fgPictures.resize(1);
}