C++ TMXLayer类代码示例

void TMXTiledMap::buildWithMapInfo(TMXMapInfo* mapInfo)
{
    _mapSize = mapInfo->getMapSize();
    _tileSize = mapInfo->getTileSize();
    _mapOrientation = mapInfo->getOrientation();

    _objectGroups = mapInfo->getObjectGroups();

    _properties = mapInfo->getProperties();

    _tileProperties = mapInfo->getTileProperties();

    int idx = 0;

    auto& layers = mapInfo->getLayers();
    for (const auto &layerInfo : layers) {
        if (layerInfo->_visible) {
            TMXLayer *child = parseLayer(layerInfo, mapInfo);
            if (child == nullptr) {
                idx++;
                continue;
            }
            addChild(child, idx, idx);
            // update content size with the max size
            const Size& childSize = child->getContentSize();
            Size currentSize = this->getContentSize();
            currentSize.width = std::max(currentSize.width, childSize.width);
            currentSize.height = std::max(currentSize.height, childSize.height);
            this->setContentSize(currentSize);

            idx++;
        }
    }
    _tmxLayerNum = idx;
}

void Player::setTagPosition(int x, int y){
	auto spriteSize = m_node->getContentSize();
	Vec2 dstPos = Vec2(x + spriteSize.width / 2, y);

	Vec2 tiledPos = tileCoorForPosition(Vec2(dstPos.x, dstPos.y));

	int tiledGid = meta->getTileGIDAt(tiledPos);

	if (tiledGid != 0){
		Value properties = m_map->getPropertiesForGID(tiledGid);
		ValueMap propertiesMap = properties.asValueMap();

		if (propertiesMap.find("Collidable") != propertiesMap.end()){
			Value prop = propertiesMap.at("Collidable");
			if (prop.asString().compare("true") == 0){
				return;
			}
		}

		if (propertiesMap.find("food") != propertiesMap.end()){
			Value prop = propertiesMap.at("food");
			if (prop.asString().compare("true") == 0){
				TMXLayer* barrier = m_map->getLayer("barrier");
				barrier->removeTileAt(tiledPos);
			}
		}
	}
	
	Entity::setTagPosition(x, y);
	setViewPointByPlayer();
}

void Bullet::bulletBoom()
{
    Rect rect = getBoundingBox();
    Size mapSize = mTileMapInfo->getTileMap()->getContentSize();

    if (rect.getMinX() < 0 || rect.getMaxX() >= mapSize.width || rect.getMinY() < 0
            || rect.getMaxY() >= mapSize.height)
        return;

    TMXLayer* tmxLayer = mTileMapInfo->getTileMap()->getLayer("layer_0");
    Size tileSize = tmxLayer->getMapTileSize();


    float MinY = mapSize.height - rect.getMinY();
    float MaxY = mapSize.height - rect.getMaxY();


    Point pt = Point((int) rect.getMinX() / tileSize.width, (int) (MinY / tileSize.height));
    if (gidToTileType[tmxLayer->getTileGIDAt(pt)] == tileWall)
        tmxLayer->setTileGID(gidToTileType[tileNone], pt);

    pt = Point((int) rect.getMinX() / tileSize.width, (int) (MaxY / tileSize.height));
    if (gidToTileType[tmxLayer->getTileGIDAt(pt)] == tileWall)
        tmxLayer->setTileGID(gidToTileType[tileNone], pt);

    pt = Point((int) rect.getMaxX() / tileSize.width, (int) (MinY / tileSize.height));
    if (gidToTileType[tmxLayer->getTileGIDAt(pt)] == tileWall)
        tmxLayer->setTileGID(gidToTileType[tileNone], pt);

    pt = Point((int) rect.getMaxX() / tileSize.width, (int) (MaxY / tileSize.height));
    if (gidToTileType[tmxLayer->getTileGIDAt(pt)] == tileWall)
        tmxLayer->setTileGID(gidToTileType[tileNone], pt);
}

//------------------------------------------------------------------
//
// TMXUncompressedTest
//
//------------------------------------------------------------------
TMXUncompressedTest::TMXUncompressedTest()
{
    auto color = LayerColor::create( Color4B(64,64,64,255) );
    addChild(color, -1);
    
    auto map = TMXTiledMap::create("TileMaps/iso-test2-uncompressed.tmx");
    addChild(map, 0, kTagTileMap);    
    
    Size CC_UNUSED s = map->getContentSize();
    CCLOG("ContentSize: %f, %f", s.width,s.height);
    
    // move map to the center of the screen
    auto ms = map->getMapSize();
    auto ts = map->getTileSize();
    map->runAction(MoveTo::create(1.0f, Vec2( -ms.width * ts.width/2, -ms.height * ts.height/2 ) ));
    
    // testing release map
    TMXLayer* layer;
    
    auto& children = map->getChildren();
    for(const auto &node : children) {
        layer= static_cast<TMXLayer*>(node);
        layer->releaseMap();
    }

}

bool SelectRoundLayer::init()
{
	if (!Layer::init())
		return false;

	// background
	std::string filePath = FileUtils::getInstance()->fullPathForFilename("selectRound.tmx");
	TiledMapParser* tiledMapParser = TiledMapParser::create(filePath);
	TMXLayer* layer = tiledMapParser->createLayer("backgroundLayer");
	addChild(layer);

	int max_passed_round = GameController::getInstance()->maxPassedRound();
	Point pos;

	// round buttons
	MapGidToGamePos map;
	tiledMapParser->getGidToGamePosMap("roundIconLayer", &map);
	MapGidToGamePos::iterator it = map.begin();
	for (; map.end() != it; ++it) {
		int round = it->first - 1;
		createRoundButton(round, GameController::getInstance()->isUnlock(round), it->second);
		if (max_passed_round == round)
			pos = it->second;
	}

	Size layer_size = layer->getLayerSize();
	Size visibleSize = Director::getInstance()->getVisibleSize();
	int height_offset = layer_size.height - visibleSize.height;
	Vec2 visibleOrigin = Director::getInstance()->getVisibleOrigin();
	setPosition(Vec2(visibleOrigin.x, visibleOrigin.y + height_offset));

	setTouchEnabled(true);

	return true;
}

void HelloWorld::initTileDatas()
{
    Size mapsize = m_gamemap->getMapSize();
    TMXLayer* layer = m_gamemap->layerNamed("block");
    assert(layer != NULL);

    for (int m = 0; m < mapsize.width; ++m)
    {
        for (int n = 0; n < mapsize.height; ++n)
        {
            uint32_t gid = layer->getTileGIDAt(Vec2(m, n));
            TileData* data = new TileData(std::make_pair(m, n));
            if (gid)
            {
                ValueMap property = m_gamemap->getPropertiesForGID(gid).asValueMap();

                if (property["block"].asString() == "true")
                    data->setWalkAble(false);
                data->setPriority(property["Priority"].asInt());
                data->setExtraHScore(property["extra"].asInt());
            }
            m_tileDatas.push_back(data);
        }
    }
}

void SimplePlatformerScene::drawCollisionTiles()
{
    TMXLayer* collisionLayer = _tileMapNode->getLayer("edgeLayer");
    auto mapSize = _tileMapNode->getMapSize();
    auto tileSize = _tileMapNode->getTileSize();
    Sprite* tile = nullptr;
    Point pos;
    for(int i = 0; i < mapSize.width; i++)
    {
        for(int j = 0; j < mapSize.height; j++)
        {
            tile = collisionLayer->getTileAt(Point(i, j));
            if(tile != nullptr)
            {
                const ValueMap property = _tileMapNode->getPropertiesForGID(collisionLayer->getTileGIDAt(Point(i, j))).asValueMap();
                bool collidable = property.at("collidable").asBool();
                if(collidable)
                {
                    pos = collisionLayer->getPositionAt(Point(i, j));
                    makeBoxObjAt(tile, tileSize, false, PhysicsMaterial(0.2f, 0.5f, 0.5f));
                }
            }
        }
    }
}

bool MapLayer::onTouchBegan(Touch *touch, Event *unused_event)
{
    Point beginPos = touch->getLocationInView();
    beginPos = Director::getInstance()->convertToGL(beginPos);

    TMXTiledMap* map = (TMXTiledMap*)this->getChildByTag(kTagTileMap);

    // 获取触摸点在地图位置上的索引
    Point mapPos = map->getPosition();
    Point aimMapIndex = convertTo2d(Point(beginPos.x - mapPos.x, beginPos.y - mapPos.y));
    if(aimMapIndex.x < 0 || aimMapIndex.y < 0 || aimMapIndex.x >= map->getMapSize().width || aimMapIndex.y >= map->getMapSize().height) {
        // 超出地图边界
        return false;
    }

    Point herop = _tamara->getPosition();
    Point mapIndex = convertTo2d(herop);
    TMXLayer* layer = map->getLayer("grass");
    int tilegid = layer->getTileGIDAt(aimMapIndex);
    Value tileValue = map->getPropertiesForGID(tilegid);
    int touchValue = tileValue.asValueMap().at("conflict").asInt();
    if(touchValue == 1) {
        return false;
    }

    _path = _myAstar->findPath(mapIndex.x, mapIndex.y, aimMapIndex.x, aimMapIndex.y, map);
    if(nullptr != _path && _path->count() >= 2) {
        _stepIndex = 1;
    } else {
        _stepIndex = -1;
    }
    _smallStepIndex = 0;

    return true;
}

// FastTMXLayer - init & alloc & dealloc
TMXLayer * TMXLayer::create(TMXTilesetInfo *tilesetInfo, TMXLayerInfo *layerInfo, TMXMapInfo *mapInfo)
{
    TMXLayer *ret = new (std::nothrow) TMXLayer();
    if (ret->initWithTilesetInfo(tilesetInfo, layerInfo, mapInfo))
    {
        ret->autorelease();
        return ret;
    }
    return nullptr;
}

// private
TMXLayer * TMXTiledMap::parseLayer(TMXLayerInfo *layerInfo, TMXMapInfo *mapInfo)
{
    TMXTilesetInfo *tileset = tilesetForLayer(layerInfo, mapInfo);
    TMXLayer *layer = TMXLayer::create(tileset, layerInfo, mapInfo);

    // tell the layerinfo to release the ownership of the tiles map.
    layerInfo->_ownTiles = false;
    layer->setupTiles();

    return layer;
}

/**
 *加载地图
*/
void HelloWorld::loadMap(const std::string& mapName)
{
    String* mapXml = String::createWithContentsOfFile("gamemap.tmx");
    m_gamemap = TMXTiledMap::createWithXML(mapXml->getCString(), "");
    assert(m_gamemap);
    TMXLayer* layer = m_gamemap->layerNamed("block");
    if (layer != NULL)
        layer->setVisible(false);

    this->addChild(m_gamemap);
}

void BattleLayer::_dealMap(){
    Size visibleSize = Director::getInstance()->getVisibleSize();
    
    _battleMapBackground = LayerColor::create(Color4B(0, 0, 0, 255), visibleSize.width, visibleSize.height);
    _battleMapBackground->setPosition(0, 0);
    this->addChild(_battleMapBackground, 0);
    
    TMXTiledMap *tiledMap = TMXTiledMap::create("res/map/battle_map.tmx");
    TMXLayer *backgroundLayer = tiledMap->getLayer("background");
    TMXLayer *walkableLayer = tiledMap->getLayer("walkable");
    
    walkableLayer->setAnchorPoint(Vec2(0.5, 0.5));
    walkableLayer->setPosition(visibleSize.width / 2, visibleSize.height / 2 + 90);
    _battleMapBackground->addChild(walkableLayer, 1);
    
    backgroundLayer->setAnchorPoint(Vec2(0.5, 0.5));
    backgroundLayer->setPosition(visibleSize.width / 2, visibleSize.height / 2 + 90);
    _battleMapBackground->addChild(backgroundLayer, 1);
    
    Size mapSize = walkableLayer->getLayerSize();
    _battleMapTileSize = Size(20, 30);
    _battleTileSize = walkableLayer->getMapTileSize();
    
    _battleMapSize = Size(20 * _battleTileSize.width, 30 * _battleTileSize.height);
    _battleMap = LayerColor::create(Color4B(255, 255, 255, 150), _battleMapSize.width, _battleMapSize.height);
    _battleMap->ignoreAnchorPointForPosition(false);
    _battleMap->setAnchorPoint(Vec2(0.5, 0.5));
    _battleMap->setPosition(visibleSize.width / 2, visibleSize.height / 2 + 90);
    _battleMapBackground->addChild(_battleMap, 5);
    
}

NS_CC_BEGIN


// TMXLayer - init & alloc & dealloc

TMXLayer * TMXLayer::create(TMXTilesetInfo *tilesetInfo, TMXLayerInfo *layerInfo, TMXMapInfo *mapInfo)
{
    TMXLayer *pRet = new TMXLayer();
    if (pRet->initWithTilesetInfo(tilesetInfo, layerInfo, mapInfo))
    {
        pRet->autorelease();
        return pRet;
    }
    return NULL;
}

bool HelloWorld::onTouchBegan(Touch* touch, Event* event)
{

    auto m_tBeginPos = Point(touch->getLocation().x,touch->getLocation().y);
    auto map = static_cast<TMXTiledMap*>( getChildByTag(1));
    Point mapp = map->getPosition();
    Point aimmapindex = convertto2d(m_tBeginPos.x - mapp.x,m_tBeginPos.y - mapp.y);
    if(aimmapindex.x < 0 || aimmapindex.y < 0 || aimmapindex.x >= map->getMapSize().width || aimmapindex.y >= map->getMapSize().height)
    {
        return false;
    }
    TMXLayer* layer = map->layerNamed("grass");
    layer->setTileGID(4,aimmapindex);
    
    return true;
}

NS_CC_BEGIN


// TMXLayer - init & alloc & dealloc

TMXLayer * TMXLayer::create(TMXTilesetInfo *tilesetInfo, TMXLayerInfo *layerInfo, TMXMapInfo *mapInfo)
{
    TMXLayer *ret = new (std::nothrow) TMXLayer();
    if (ret->initWithTilesetInfo(tilesetInfo, layerInfo, mapInfo))
    {
        ret->autorelease();
        return ret;
    }
    CC_SAFE_DELETE(ret);
    return nullptr;
}