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;
}
Example #2
0
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();
}
Example #3
0
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);
}
Example #4
0
//------------------------------------------------------------------
//
// 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();
    }

}
Example #5
0
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;
}
Example #6
0
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));
                }
            }
        }
    }
}
Example #8
0
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;
}
Example #11
0
/**
 *加载地图
*/
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);
}
Example #12
0
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;
}
Example #14
0
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;
}
Example #15
0
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;
}
Example #16
0
bool MapScene::init()
{
	if (!Layer::create())
	{
		return false;
	}
	/*╪стьмъф╛╣ьм╪*/

	switch (this->step)
	{
	case 1:{
			   std::string file = "Map.tmx";
			   auto str = String::createWithContentsOfFile(FileUtils::getInstance()->fullPathForFilename(file.c_str()).c_str());
			   this->map = TMXTiledMap::createWithXML(str->getCString(), "");
			   TMXLayer* obscatle= map->layerNamed("obscatle");
			   obscatle->setVisible(false);
			   this->objGroup = map->getObjectGroup("Object");
			   this->addChild(map, 0);
	}break;
	case 2:{
			   std::string file = "MapStep2.tmx";
			   auto str = String::createWithContentsOfFile(FileUtils::getInstance()->fullPathForFilename(file.c_str()).c_str());
			   this->map = TMXTiledMap::createWithXML(str->getCString(), "");
			   TMXLayer* obscatle = map->layerNamed("obscatle");
			   obscatle->setVisible(false);
			   this->objGroup = map->getObjectGroup("Object"); 
			   this->addChild(map, 0);

	}break;
	case 3:{
			   std::string file = "MapStep3.tmx";
			   auto str = String::createWithContentsOfFile(FileUtils::getInstance()->fullPathForFilename(file.c_str()).c_str());
			   this->map = TMXTiledMap::createWithXML(str->getCString(), "");
			   TMXLayer* obscatle = map->layerNamed("obscatle");
			   obscatle->setVisible(false);
			   this->objGroup = map->getObjectGroup("Object");
			   this->addChild(map, 0);

	}break;
	default:
		break;
	}

	
	
	return true;
}
Example #17
0
void BattleLayer::_makeAStarData(){
    TMXTiledMap *tiledMap = TMXTiledMap::create("res/map/battle_map.tmx");
    TMXLayer *walkableLayer = tiledMap->getLayer("walkable");
    Size mapSize = walkableLayer->getLayerSize();
//    CCLOG("MapSize: (%f, %f)", mapSize.width, mapSize.height);
    
    AStarDataNode astarDataVec[20][30];
    
    for (int column = 0; column < _battleMapTileSize.width; ++column){
        for (int row = 0; row < _battleMapTileSize.height; ++row){
            Vec2 tileCoord = Vec2(column + 5, mapSize.height - (row + 5) - 1);
            int tileGID = walkableLayer->getTileGIDAt(tileCoord);
            
            if (tileGID > 0){
                Value value = tiledMap->getPropertiesForGID(tileGID);
                ValueMap valueMap = value.asValueMap();
                int walkable = valueMap["walkable"].asInt();
//                CCLOG("Column: %d, Row: %d, Walkable: %d", column, row, walkable);
                
                astarDataVec[column][row].column = column;
                astarDataVec[column][row].row = row;
                astarDataVec[column][row].walkable = (walkable == 0) ? false : true;
                
            }
        }
    }
    
    for (int column = 0; column < _battleMapTileSize.width; ++column){
        std::vector<AStarDataNode> oneList;
        std::vector<BattleElement *> oneBattleElementList;
        for (int row = 0; row < _battleMapTileSize.height; ++row){
            AStarDataNode astarDataNode = AStarDataNode(column, row, astarDataVec[column][row].walkable);
            oneList.push_back(astarDataNode);
            oneBattleElementList.push_back(nullptr);
        }
        astarData.push_back(oneList);
        battleElements.push_back(oneBattleElementList);
    }
    
//    for (int row = 0; row < _battleMapTileSize.height; ++row){
//        for (int column = 0; column < _battleMapTileSize.width; ++column){
//            printf("%d", astarData[column][row].walkable);
//        }
//        printf("\n");
//    }
}
Example #18
0
//------------------------------------------------------------------
//
// TMXTilesetTest
//
//------------------------------------------------------------------
TMXTilesetTest::TMXTilesetTest()
{
    auto map = TMXTiledMap::create("TileMaps/orthogonal-test5.tmx");
    addChild(map, 0, kTagTileMap);
    
    Size CC_UNUSED s = map->getContentSize();
    CCLOG("ContentSize: %f, %f", s.width,s.height);
    
    TMXLayer* layer;
    layer = map->getLayer("Layer 0");
    layer->getTexture()->setAntiAliasTexParameters();
    
    layer = map->getLayer("Layer 1");
    layer->getTexture()->setAntiAliasTexParameters();

    layer = map->getLayer("Layer 2");
    layer->getTexture()->setAntiAliasTexParameters();
}
// public
TMXLayer * TMXTiledMap::getLayer(const std::string& layerName) const
{
    CCASSERT(layerName.size() > 0, "Invalid layer name!");
    
    for (auto& child : _children)
    {
        TMXLayer* layer = dynamic_cast<TMXLayer*>(child);
        if(layer)
        {
            if(layerName.compare( layer->getLayerName()) == 0)
            {
                return layer;
            }
        }
    }

    // layer not found
    return nullptr;
}
Example #20
0
TMXResizeTest::TMXResizeTest()
{
    auto map = TMXTiledMap::create("TileMaps/orthogonal-test5.tmx");
    addChild(map, 0, kTagTileMap);
    
    Size CC_UNUSED s = map->getContentSize();
    CCLOG("ContentSize: %f, %f", s.width,s.height);

    TMXLayer* layer;
    layer = map->getLayer("Layer 0");

    auto ls = layer->getLayerSize();
    for (unsigned int y = 0; y < ls.height; y++) 
    {
        for (unsigned int x = 0; x < ls.width; x++) 
        {
            layer->setTileGID(1, Vec2( x, y ) );
        }
    }        
}
Example #21
0
// 检测地图上该点是否能通过
bool Astar::checkMap(int col, int row)
{
    // 检查地图中是否有碰撞
    if(abs(_aimCol - col) > 0 || abs(_aimRow - row) > 0) {
        TMXLayer* layer = _map->getLayer("grass");
        int tilegid = layer->getTileGIDAt(Point(col, row));

        //Dictionary* tiledic = _map->propertiesForGID(tilegid);
        //String* mvalue = (String*)tiledic->objectForKey("conflict");
        //int mv = mvalue->intValue();
        Value tileValue = _map->getPropertiesForGID(tilegid);
        int touchValue = tileValue.asValueMap().at("conflict").asInt();
        if(touchValue == 1) {
            // 检测到有碰撞
            return false;
        }
    }

    return true;
}
Example #22
0
bool Global::tileAllowMove(Point MovePoint)
{
	TMXLayer *metaLayer = global->tileMap->getLayer("Meta");
	Point tileCoord = tilePosFromLocation(MovePoint, global->tileMap);
	int tileGid = metaLayer->getTileGIDAt(tileCoord);

	if (tileGid)
	{
		auto properties = tileMap->getPropertiesForGID(tileGid).asValueMap();
		if (!properties.empty())
		{
			auto collision = properties["Collidable"].asString();
			if ("True" == collision)
				return false;
			else
				return true;
		}
		else
			return true;
	}
	return true;
}
void GameMap::tryMovePlayer(Vec2 toPos) {
	//禁止移动事项
	if (isShowDialogue){ return; }

	Vec2 coor = getTileCoordinateAt(toPos - getMapLeftBottomPos());
	Size mapSize = this->_map->getMapSize();

	if (coor.x >= mapSize.width || coor.x < 0 || coor.y >= mapSize.height || coor.y < 0){
		return;//要到达目标在地图外
	}

	TMXLayer* blockLayer = _map->getLayer("block");
	if (blockLayer != NULL &&  blockLayer->getTileAt(coor) != NULL){
		return;//要到达的目标有障碍物
	}

	ValueMap inspectObject = getInspectObjectAt(toPos);
	if (inspectObject != ValueMapNull && inspectObject["isBlock"].asBool() == true){
		return;//当要到达的位置有可以调查的物体且该物体属性为可以被阻挡时
	}

	_player->setPosition(toPos);
}
std::vector<cocos2d::Vec2> SpriteInMap::findPath(cocos2d::Vec2 src, cocos2d::Vec2 dst)
{
    int iter_sin[]={0,1,0,-1};
    int iter_cos[]={1,0,-1,0};
    struct path_element {
        int x,y;
        float f,g;
        int prev_x,prev_y;
        bool closedset;
        bool openset;
    };
    //    int prev[(int)map_isize.width][(int)map_isize.height][3]; // 0 prev_x 1 prev_y 2 cost
    path_element mapa[(int)map_isize.width][(int)map_isize.height];
    for (int i=0;i<(int)map_isize.width;i++)
        for (int j=0;j<(int)map_isize.height;j++) {
            mapa[i][j].closedset=false;
            mapa[i][j].openset=false;
        }
    
    //vector<path_element> closed;
    priority_queue<path_element*,vector<path_element*>,function<bool(path_element*,path_element*)> > openq( [] (path_element *a, path_element *b) {
        return (a->f > b->f);
    });
    
    TMXLayer *maplayer = themap->getLayer("main");
    
    //themap->getLayer("selection")->setTileGID(13,Vec2(0,0));
    
    int sx=src.x;
    int sy=src.y;
    path_element *start = &mapa[sx][sy];
    start->x=src.x;
    start->y=src.y;
    start->g=0;
    start->f=0+abs(src.x-dst.x)+abs(src.y-dst.y);
    start->openset=true;
    openq.push(start);
    
    vector<Vec2> reverse_path;
    reverse_path.clear();
    
    while ( !openq.empty() ) {
        //cout << "openqueue size: " <<openq.size() <<"\n";
        path_element *current = openq.top(); openq.pop();
        //cout << "selected ("<<current->x<<","<<current->y<<")\n";
        if ( abs(current->x-dst.x)<0.5 && abs(current->y-dst.y)<0.5 ) {
            //cout<<"found\n";
            path_element *e = current;
            do {
                reverse_path.push_back(Vec2(e->x,e->y));
                e=&mapa[e->prev_x][e->prev_y];
            } while (e!=start);
            return reverse_path;
        }
        int cx=(int)current->x;
        int cy=(int)current->y;
        mapa[cx][cy].closedset=true;
        mapa[cx][cy].openset=false;
        for (int i=0;i<4;i++) {
            int nx=cx+iter_cos[i];
            int ny=cy+iter_sin[i];
            if (maplayer->getTileGIDAt(Vec2(nx,ny))!=0) continue;
            path_element *nb = &mapa[nx][ny];
            //cout << "n ("<<nx<<","<<ny<<")\n";
            if (nb->closedset) continue;
            if (nx<0 || ny<0 || nx>map_isize.width-1 || ny>map_isize.height-1) continue;
            if ( (!nb->openset) || (1+current->g<nb->g) ) {
                //cout << "changed\n";
                nb->x=nx;
                nb->y=ny;
                nb->g=1+current->g;
                nb->f=nb->g+abs(nb->x-dst.x)+abs(nb->y-dst.y);
                nb->prev_x=cx;
                nb->prev_y=cy;
                if (!nb->openset) openq.push(nb);
                nb->openset=true;
                // cout<<"f: "<<nb->g<<" g: "<<nb->f<<" \n";
            }
        }
    }
    return reverse_path;
}
Example #25
0
void SpaceGameLayer::super_init(const char*map_name,uint32_t res_scale) {
  scale = res_scale;
  cocos2d::Layer::init();
  auto director = cocos2d::Director::getInstance();
  this->setScale(1);
  float sf = director->getContentScaleFactor();
  this->setAnchorPoint(cocos2d::Point(0, 0));

  ////////////////////////////////////
  // LEVEL-SETUP - GENERAL
  level = new Level();
  level->loadMap(map_name,scale);
  this->addChild(level);
  level->setPosition(0, 0);
  // Special atribute layers


  string fgs = "foreground";
  int fg_cnt = 1;
  TMXLayer *fg = level->map->getLayer((fgs + std::to_string(fg_cnt)));
  while (fg != NULL) {
    this->addChild(fg, 10);
    fg->setScale(level->getScale());
    fg_cnt++;
    fg = level->map->getLayer((fgs + std::to_string(fg_cnt)));
  }

 
  string bgs = "background";
  int bg_cnt = 1;
  TMXLayer *bg = level->map->getLayer((bgs + std::to_string(bg_cnt)));
 
  while (bg != NULL) {
    bg->setScale(scale);
    background_layers.pushBack(bg);
    bg = level->map->getLayer((bgs + std::to_string(bg_cnt)));
    bg_cnt++;
  }


  ////////////////////////////////////
  // OUTSIDE OF SCREEN RECTANGLE - GENERAL - This rect is used to determine which go's are on/off-screen
  outside_screen = 1.5;
  float screnWidh = director->getWinSize().width*outside_screen;
  float screnHeight = director->getWinSize().height*outside_screen;
  float distanceX = (screnWidh - screnWidh / outside_screen) / 2;
  float distanceY = (screnHeight - screnHeight / outside_screen) / 2;
  screen.setRect(getPositionX() - distanceX, getPositionY() - distanceY, screnWidh, screnHeight);

  if (view_of_screen_rect) {
    screen_draw = cocos2d::DrawNode::create();
    cocos2d::Vec2 rectangle[4];
    rectangle[0] = cocos2d::Vec2(screen.getMinX(), screen.getMinY());
    rectangle[1] = cocos2d::Vec2(screen.getMaxX(), screen.getMinY());
    rectangle[2] = cocos2d::Vec2(screen.getMaxX(), screen.getMaxY());
    rectangle[3] = cocos2d::Vec2(screen.getMinX(), screen.getMaxY());
    screen_draw->drawPolygon(rectangle, 4, cocos2d::Color4F::RED, 1, cocos2d::Color4F::BLUE);
    screen_draw->setAnchorPoint(getAnchorPoint());
    addChild(screen_draw, 3);
  }


  ////////////////////////////////////
  // SPAWN GAME OBJACTS - SPECIFIC
  getObjects(sf);

  if (hero != NULL) {
    setViewPointCenter(hero->getCameraView());
    Hero_Gui *hg = new Hero_Gui();
    hg->hero = hero;
    addChild(hg);
  }
  ////////////////////////////////////
  // MUSIC SETUP - SPECIFIC
  auto mapGroup = level->getMap()->getProperties();
  string track_name = mapGroup["music_track"].asString();
  auto audio = CocosDenshion::SimpleAudioEngine::getInstance();
  if (track_name == "") {
    current_track = "";
    audio->stopBackgroundMusic();
  }
  else if (track_name != current_track) {
    current_track = track_name;
    audio->playBackgroundMusic(track_name.c_str(), true);
  }

}
void PlayMapSix::onEnter() {
	Layer::onEnter();

	bisover = false;
	//visibleSize,屏幕尺寸
	visibleSize = Director::getInstance()->getVisibleSize();

	//添加碰撞监听器
	contactListener = EventListenerPhysicsContact::create();
	contactListener->onContactBegin = CC_CALLBACK_1(PlayMapSix::onContactBegin, this);
	contactListener->onContactPostSolve = CC_CALLBACK_2(PlayMapSix::onContactPostSolve, this);
	contactListener->onContactPreSolve = CC_CALLBACK_2(PlayMapSix::onContactPreSolve, this);
	contactListener->onContactSeparate = CC_CALLBACK_1(PlayMapSix::onContactSeparate, this);
	//事件分发器
	auto eventDispatcher = Director::getInstance()->getEventDispatcher();
	eventDispatcher->addEventListenerWithSceneGraphPriority(contactListener, this);

	//网格地图
	auto winSize = Director::getInstance()->getWinSize();
	//map00瓦片地图地图
	tilemap = TMXTiledMap::create("map/map6.tmx");
	tilemap->setAnchorPoint(Vec2(0,0));
	tilemap->setPosition(Vec2(0,0));
	//auto group = tilemap->getObjectGroup("objects");
	this->addChild(tilemap,-1);

	TMXObjectGroup *objects = tilemap->getObjectGroup("objLayer");
	CCASSERT(NULL != objects, "'Objects' object group not found");
	auto spawnPoint = objects->getObject("hero");
	CCASSERT(!spawnPoint.empty(), "SpawnPoint object not found");
	print_x = spawnPoint["x"].asInt();
	print_y = spawnPoint["y"].asInt();


	TMXLayer* layer = tilemap->getLayer("collideLayer");//从map中取出“bricks”图层
	//这个循环嵌套是为了给每个砖块精灵设置一个刚体
	int count = 0; 
	for (int y = 0; y<TMX_HEIGHT; y++)
	{
		log("xxxxxxxxxxxxxxxxxxxx:%d", y); int groundcounter = 0; int deadlinecounter = 0; int dispearcounter = 0; int bodycounter = 0;
		Point groundpoint, deadlinepoint, dispearpoint, bodypoint; Size groundsize, deadlinesize, dispearsize, bodysize;
		for (int x = 0; x<TMX_WIDTH; x++)
		{

			int gid = layer->getTileGIDAt(Vec2(x, y));
			Sprite* sprite = layer->getTileAt(Vec2(x, y));//从tile的坐标取出对应的精灵

			if (gid == GROUND_GID) {

				log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
				if (groundcounter == 0) {
					groundpoint = Point(sprite->getPosition().x, sprite->getPosition().y);
					groundsize = sprite->getContentSize();
					log("groundcounter==0");
				}
				groundcounter++; log("groundcounter=%d", groundcounter);

			}
			else {
				if (groundcounter != 0) {
					log("make execute!");
					groundsize = Size(groundsize.width*groundcounter, groundsize.height);
					log("point=%f  %f,size=%f  %f", groundpoint.x, groundpoint.y, groundsize.width, groundsize.height);
					this->makePhysicsObjAt(groundpoint, groundsize, false, 0, 0.0f, 0.0f, 0, GROUND_GID, -1);
				}
				groundcounter = 0;
			}/////////////////
			if (gid == DEAD_LINE_GID) {

				log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
				if (deadlinecounter == 0) {
					deadlinepoint = Point(sprite->getPosition().x, sprite->getPosition().y);
					deadlinesize = sprite->getContentSize();
					log("groundcounter==0");
				}
				deadlinecounter++; log("groundcounter=%d", deadlinecounter);

			}
			else {
				if (deadlinecounter != 0) {
					log("make execute!");
					deadlinesize = Size(deadlinesize.width*deadlinecounter, deadlinesize.height);
					log("point=%f  %f,size=%f  %f", deadlinepoint.x, deadlinepoint.y, deadlinesize.width, deadlinesize.height);
					this->makePhysicsObjAt(deadlinepoint, deadlinesize, false, 0, 0.0f, 0.0f, 0, DEAD_LINE_GID, -1);
				}
				deadlinecounter = 0;
			}
			if (gid == CAN_DISPEAR_GID) {
				sprite->setTag(count);
				log("sprite->setTag(%d);", count);
				log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
				if (dispearcounter == 0) {
					dispearpoint = Point(sprite->getPosition().x, sprite->getPosition().y);
					dispearsize = sprite->getContentSize();
					log("groundcounter==0");
				}
				dispearcounter++; log("groundcounter=%d", dispearcounter);

			}
			else {
				if (dispearcounter != 0) {
					log("make execute!");
					dispearsize = Size(dispearsize.width*dispearcounter, dispearsize.height);
					log("point=%f  %f,size=%f  %f", dispearpoint.x, dispearpoint.y, dispearsize.width, dispearsize.height);
					this->makePhysicsObjAt(dispearpoint, dispearsize, false, 0, 0.0f, 0.0f, 0, CAN_DISPEAR_GID, count);
					count++;
				}
				dispearcounter = 0;
			}
			if (gid == BODY_GID) {

				log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
				if (bodycounter == 0) {
					bodypoint = Point(sprite->getPosition().x, sprite->getPosition().y);
					bodysize = sprite->getContentSize();
					log("groundcounter==0");
				}
				bodycounter++; log("groundcounter=%d", bodycounter);

			}
			else {
				if (bodycounter != 0) {
					log("make execute!");
					bodysize = Size(bodysize.width*bodycounter, bodysize.height);
					log("point=%f  %f,size=%f  %f", bodypoint.x, bodypoint.y, bodysize.width, bodysize.height);
					this->makePhysicsObjAt(bodypoint, bodysize, false, 0, 0.0f, 0.0f, 0, BODY_GID, -1);
				}
				bodycounter = 0;
			}
			if (count == 10000)count = 0;
		}
	}

/*******    原始添加刚体算法,当刚体太多容易造成屏幕反应迟钝,故优化为以上算法    **************
	for (int y = 0; y<TMX_HEIGHT; y++)
	{
		log("xxxxxxxxxxxxxxxxxxxx:%d",y);
		for (int x = 0; x<TMX_WIDTH; x++)
		{
			log("yyyyyyyyyyyyyyyyy:%d",x);
			int gid = layer->getTileGIDAt(Vec2(x, y));//为了提高点效率,我们没必要给每个tile加上刚体,在创建地图时我们设定了空白处的gid值为12,因此我们只对非12的tile加上刚体
			log("GGIIDD %d",gid);
			switch (gid)
			{
			case GROUND_GID:
				{
					log("GGGGGGGGGGGGIIIIIIIIIIIIIDDDDDDDDDDDDD");
					Sprite* sprite = layer->getTileAt(Vec2(x, y));//从tile的坐标取出对应的精灵
					log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
					auto point = Point(sprite->getPosition().x, sprite->getPosition().y);
					auto size = Size(sprite->getContentSize().width, sprite->getContentSize().height);
					log("xxxxxxxxxxx  %f,llllllllllll %f", sprite->getContentSize().width, sprite->getContentSize().height);
					this->makePhysicsObjAt(point, size, false, 0, 0.0f, 0.0f, 0, GROUND_GID,-1);
				}break;
			case DEAD_LINE_GID:
			{
				Sprite* sprite = layer->getTileAt(Vec2(x, y));//从tile的坐标取出对应的精灵
				log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
				auto point = Point(sprite->getPosition().x, sprite->getPosition().y);
				auto size = Size(sprite->getContentSize().width, sprite->getContentSize().height);
				log("xxxxxxxxxxx  %f,llllllllllll %f", sprite->getContentSize().width, sprite->getContentSize().height);
				this->makePhysicsObjAt(point, size, false, 0, 0.0f, 0.0f, 0, DEAD_LINE_GID,-1);
			}break;
			case CAN_DISPEAR_GID:
			{
				Sprite* sprite = layer->getTileAt(Vec2(x, y));//从tile的坐标取出对应的精灵
				sprite->setTag(count);
				log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
				auto point = Point(sprite->getPosition().x, sprite->getPosition().y);
				auto size = Size(sprite->getContentSize().width, sprite->getContentSize().height);
				log("xxxxxxxxxxx  %f,llllllllllll %f", sprite->getContentSize().width, sprite->getContentSize().height);
				this->makePhysicsObjAt(point, size, false, 0, 0.0f, 0.0f, 0, CAN_DISPEAR_GID,count);
				count++;
			}break;
			case  BODY_GID:
			{
				log("GGGGGGGGGGGGIIIIIIIIIIIIIDDDDDDDDDDDDD");
				Sprite* sprite = layer->getTileAt(Vec2(x, y));//从tile的坐标取出对应的精灵
				log("sssssssssss  %f,ppppppppppppp %f", sprite->getPosition().x, sprite->getPosition().y);
				auto point = Point(sprite->getPosition().x, sprite->getPosition().y);
				auto size = Size(sprite->getContentSize().width, sprite->getContentSize().height);
				log("xxxxxxxxxxx  %f,llllllllllll %f", sprite->getContentSize().width, sprite->getContentSize().height);
				this->makePhysicsObjAt(point, size, false, 0, 0.0f, 0.0f, 0, GROUND_GID, -1);
			}break;
			default:
				break;
			}
			if (count == 10000)count = 0;
		}
	}
*/
	/*
	//带物理的会动的
	dead = DeadStar::create();
	dead->initWithFile("dead.png");			
	dead->setAnchorPoint(Point(0, 0);
	dead->setPosition(visibleSize.width / 2 + 20, visibleSize.height / 3 + 400);
	dead->getPhysicsBody()->setContactTestBitmask(DEAD_LINE);
	this->addChild(dead);
	*/

	//加入障碍物
//	auto obstacle1 = Obstacle::create();
//	obstacle1->setAnchorPoint(Point(0, 0));//
//	obstacle1->setPosition(visibleSize.width / 2+300 , visibleSize.height /2);
//	obstacle1->getPhysicsBody()->setContactTestBitmask(OBJECT_BIT_MASK);
//	this->addChild(obstacle1);

	//加入圆形
	/*
	auto circular = Circular::create();
	circular->setPosition(visibleSize.width / 2 + 100, visibleSize.height / 3+50);
	circular->getPhysicsBody()->setContactTestBitmask(OBJECT_BIT_MASK);
	addChild(circular);

	auto circular2 = Circular::create();
	circular2->setPosition(visibleSize.width / 2 + 100, visibleSize.height / 3 + 100);
	circular2->getPhysicsBody()->setContactTestBitmask(OBJECT_BIT_MASK);
	addChild(circular2);*/

	//加入小怪兽
//	MA1 = MonsterA::create();
//	MA1->initWithFile("redcircle.png");
//	MA1->setAnchorPoint(Point(0, 1));////////////////
//	MA1->setPosition(visibleSize.width *2 + 60, visibleSize.height / 3 + 200);
//	MA1->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
//	log("MA1 - getTag();%d", MA1 - getTag());
//	this->addChild(MA1);

// 设置准确位置,放置怪兽;
	auto printM1 = objects->getObject("monster1");
	//	CCASSERT(!printM1.empty(), "SpawnPoint object not found");
	int x1 = printM1["x"].asInt();
	int y1 = printM1["y"].asInt();
	//	auto _player = Sprite::create("orangetriangle.png");
	auto player1 = MonsterD::create();
	//player1->initWithFile("orangetriangle.png");
	player1->setAnchorPoint(Point(0, 1));
	player1->setPosition(x1, y1);
	player1->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
	addChild(player1);
	//setViewPointCenter(_player->getPosition());

	auto printM2 = objects->getObject("monster2");
	//	CCASSERT(!printM2.empty(), "SpawnPoint object not found");
	int x2 = printM2["x"].asInt();
	int y2 = printM2["y"].asInt();
	//	auto _player = Sprite::create("orangetriangle.png");
	auto player2 = MonsterD::create();
	//player2->initWithFile("orangetriangle.png");
	player2->setAnchorPoint(Point(0, 1));
	player2->setPosition(x2, y2);
	player2->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
	addChild(player2);

	auto printM3 = objects->getObject("monster3");
	//	CCASSERT(!printM3.empty(), "SpawnPoint object not found");
	int x3 = printM3["x"].asInt();
	int y3 = printM3["y"].asInt();
	//	auto _player = Sprite::create("orangetriangle.png");
	auto player3 = MonsterD::create();
	//player2->initWithFile("orangetriangle.png");
	player3->setAnchorPoint(Point(0, 1));
	player3->setPosition(x3, y3);
	player3->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
	addChild(player3);

	auto printM4 = objects->getObject("monster4");
	//	CCASSERT(!printM4.empty(), "SpawnPoint object not found");
	int x4 = printM4["x"].asInt();
	int y4 = printM4["y"].asInt();
	//	auto _player = Sprite::create("orangetriangle.png");
	auto player4 = MonsterD::create();
	//player1->initWithFile("orangetriangle.png");
	player4->setAnchorPoint(Point(0, 1));
	player4->setPosition(x4, y4);
	player4->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
	addChild(player4);
	//setViewPointCenter(_player->getPosition());

	auto printM5 = objects->getObject("monster5");
	//	CCASSERT(!printM5.empty(), "SpawnPoint object not found");
	int x5 = printM5["x"].asInt();
	int y5 = printM5["y"].asInt();
	//	auto _player = Sprite::create("orangetriangle.png");
	auto player5 = MonsterD::create();
	//player2->initWithFile("orangetriangle.png");
	player5->setAnchorPoint(Point(0, 1));
	player5->setPosition(x5, y5);
	player5->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
	addChild(player5);

	auto printM6 = objects->getObject("monster6");
	//	CCASSERT(!printM6.empty(), "SpawnPoint object not found");
	int x6 = printM6["x"].asInt();
	int y6 = printM6["y"].asInt();
	//	auto _player = Sprite::create("orangetriangle.png");
	auto player6 = MonsterD::create();
	//player2->initWithFile("orangetriangle.png");
	player6->setAnchorPoint(Point(0, 1));
	player6->setPosition(x6, y6);
	player6->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
	addChild(player6);

	auto printM7 = objects->getObject("monster7");
	//	CCASSERT(!printM1.empty(), "SpawnPoint object not found");
	int x7 = printM7["x"].asInt();
	int y7 = printM7["y"].asInt();
	//	auto _player = Sprite::create("orangetriangle.png");
	auto player7 = MonsterD::create();
	//player1->initWithFile("orangetriangle.png");
	player7->setAnchorPoint(Point(0, 1));
	player7->setPosition(x7, y7);
	player7->getPhysicsBody()->setContactTestBitmask(MONSTER1_BIT_MASK);
	addChild(player7);
	//setViewPointCenter(_player->getPosition());

	//加入门
	auto door = Ground::create();
	door->groundSize = Size(visibleSize.width / 6, visibleSize.height/4);
	door->init(door->groundSize);
	door->getPhysicsBody()->setContactTestBitmask(DOOR_BIT_MASK);
	//stage1->setAnchorPoint(Point(0, 1));visibleSize.width / 2, visibleSize.height / 3
	door->setPosition(door->groundSize.width / 2 + visibleSize.width * 5, door->groundSize.height / 2 + visibleSize.height / 3);
	addChild(door);
	auto doorpicture = Sprite::create("road_5.png");	//静态的,为不动的刚体添加图片使用这种方式
	doorpicture->setAnchorPoint(Point(0, 0));
	doorpicture->setPosition(visibleSize.width * 5, visibleSize.height / 3);
	this->addChild(doorpicture);//

	//加入桥
	/*
	bridge = Board::create();
	bridge->setPosition(100, 100);
	bridge->setPosition(visibleSize.width / 2 + 20, visibleSize.height / 3 + 200);
	addChild(bridge);*/

	state = 0;
	scheduleUpdate();
}
Example #27
0
bool TMXSceneEncoder::parseTmx(const XMLDocument& xmlDoc, TMXMap& map, const string& inputDirectory) const
{
    const XMLElement* xmlMap = xmlDoc.FirstChildElement("map");
    if (!xmlMap)
    {
        LOG(1, "Missing root <map> element.\n");
        return false;
    }

    // Read in the map values //XXX should compact this so XML attribute parsing is a little nicer
    unsigned int uiValue;
    int iValue;
    const char* attValue = xmlMap->Attribute("width");
    sscanf(attValue, "%u", &uiValue);
    map.setWidth(uiValue);

    attValue = xmlMap->Attribute("height");
    sscanf(attValue, "%u", &uiValue);
    map.setHeight(uiValue);

    float fValue;
    attValue = xmlMap->Attribute("tilewidth");
    sscanf(attValue, "%f", &fValue);
    map.setTileWidth(fValue);

    attValue = xmlMap->Attribute("tileheight");
    sscanf(attValue, "%f", &fValue);
    map.setTileHeight(fValue);

    // Now we load all tilesets
    const XMLElement* xmlTileSet = xmlMap->FirstChildElement("tileset");
    while (xmlTileSet)
    {
        TMXTileSet tileSet;

        attValue = xmlTileSet->Attribute("firstgid");
        sscanf(attValue, "%u", &uiValue);
        tileSet.setFirstGid(uiValue);

        XMLDocument sourceXmlDoc;
        const XMLElement* xmlTileSetToLoad;
        attValue = xmlTileSet->Attribute("source");
        if (attValue)
        {
            XMLError err;
            string tsxLocation = buildFilePath(inputDirectory, attValue);
            if ((err = sourceXmlDoc.LoadFile(tsxLocation.c_str())) != XML_NO_ERROR)
            {
                LOG(1, "Could not load tileset's source TSX.\n");
                return false;
            }
            xmlTileSetToLoad = sourceXmlDoc.RootElement();
        }
        else
        {
            xmlTileSetToLoad = xmlTileSet;
        }

        // Maximum tile size
        attValue = xmlTileSetToLoad->Attribute("tilewidth");
        if (attValue)
        {
            sscanf(attValue, "%u", &uiValue);
            tileSet.setMaxTileWidth(uiValue);
        }
        else
        {
            tileSet.setMaxTileWidth(map.getTileWidth());
        }
        attValue = xmlTileSetToLoad->Attribute("tileheight");
        if (attValue)
        {
            sscanf(attValue, "%u", &uiValue);
            tileSet.setMaxTileHeight(uiValue);
        }
        else
        {
            tileSet.setMaxTileHeight(map.getTileHeight());
        }

        // Spacing and margin
        attValue = xmlTileSetToLoad->Attribute("spacing");
        if (attValue)
        {
            sscanf(attValue, "%u", &uiValue);
            tileSet.setSpacing(uiValue);
        }
        attValue = xmlTileSetToLoad->Attribute("margin");
        if (attValue)
        {
            sscanf(attValue, "%u", &uiValue);
            tileSet.setMargin(uiValue);
        }

        // Tile offset
        const XMLElement* xmlTileOffset = xmlTileSetToLoad->FirstChildElement("tileoffset");
        if (xmlTileOffset)
        {
            Vector2 offset;

            attValue = xmlTileOffset->Attribute("x");
            sscanf(attValue, "%d", &iValue);
            offset.x = iValue;
            attValue = xmlTileOffset->Attribute("y");
            sscanf(attValue, "%d", &iValue);
            offset.y = iValue;

            tileSet.setOffset(offset);
        }

        // Load image source. Don't worry about <data> or trans
        const XMLElement* xmlTileSetImage = xmlTileSetToLoad->FirstChildElement("image");
        if (!xmlTileSetImage)
        {
            LOG(1, "Could not find <image> element for tileset.\n");
            return false;
        }
        tileSet.setImagePath(xmlTileSetImage->Attribute("source"));

        if (xmlTileSetImage->Attribute("width") && xmlTileSetImage->Attribute("height"))
        {
            attValue = xmlTileSetImage->Attribute("width");
            sscanf(attValue, "%u", &uiValue);
            tileSet.setImageWidth(uiValue);

            attValue = xmlTileSetImage->Attribute("height");
            sscanf(attValue, "%u", &uiValue);
            tileSet.setImageHeight(uiValue);
        }
        else
        {
            // Load the image itself to get the width
            string imageLocation = buildFilePath(inputDirectory, tileSet.getImagePath());
            int pos = imageLocation.find_last_of('.');
            if (imageLocation.substr(pos).compare(".png") != 0)
            {
                LOG(1, "TileSet image must be a PNG. %s\n", imageLocation.c_str());
                return false;
            }

            Image* img = Image::create(imageLocation.c_str());
            if (!img)
            {
                LOG(1, "Could not load TileSet image. %s\n", imageLocation.c_str());
                return false;
            }
            tileSet.setImageWidth(img->getWidth());
            tileSet.setImageHeight(img->getHeight());
            SAFE_DELETE(img);
        }

        //TODO: tiles (specifically, tile animations) if possible. May require marking tiles as special tiles, and spinning them off to Sprites
        //<tile id="relId"><animation><frame tileid="relId" duration="numInMS"></...></...></...>

        // Save the tileset
        map.addTileSet(tileSet);

        xmlTileSet = xmlTileSet->NextSiblingElement("tileset");
    }

    // Load the layers
    const XMLElement* xmlLayer = xmlMap->FirstChildElement("layer");
    while (xmlLayer)
    {
        TMXLayer* layer = new TMXLayer();

        parseBaseLayerProperties(xmlLayer, layer);

        // Load properties
        attValue = xmlLayer->Attribute("width");
        if (attValue)
        {
            sscanf(attValue, "%u", &uiValue);
            layer->setWidth(uiValue);
        }
        else
        {
            layer->setWidth(map.getWidth());
        }

        attValue = xmlLayer->Attribute("height");
        if (attValue)
        {
            sscanf(attValue, "%u", &uiValue);
            layer->setHeight(uiValue);
        }
        else
        {
            layer->setHeight(map.getHeight());
        }

        // Load tiles
        layer->setupTiles();
        auto data = loadDataElement(xmlLayer->FirstChildElement("data"));
        size_t dataSize = data.size();
        for (int i = 0; i < dataSize; i++)
        {
            //XXX this might depend on map's renderorder... not sure
            unsigned int x = i % layer->getWidth();
            unsigned int y = i / layer->getWidth();
            layer->setTile(x, y, data[i]);
        }

        // Save layer
        map.addLayer(layer);

        xmlLayer = xmlLayer->NextSiblingElement("layer");
    }

    // Load image layers
    const XMLElement* xmlImgLayer = xmlMap->FirstChildElement("imagelayer");
    while (xmlImgLayer)
    {
        TMXImageLayer* imgLayer = new TMXImageLayer();

        parseBaseLayerProperties(xmlImgLayer, imgLayer);

        // Load properties
        attValue = xmlImgLayer->Attribute("x");
        if (attValue)
        {
            sscanf(attValue, "%d", &iValue);
            imgLayer->setX(iValue);
        }
        attValue = xmlImgLayer->Attribute("y");
        if (attValue)
        {
            sscanf(attValue, "%d", &iValue);
            imgLayer->setY(iValue);
        }

        // Load image source. Don't worry about <data>, trans, width, or height
        const XMLElement* xmlImage = xmlImgLayer->FirstChildElement("image");
        if (!xmlImage)
        {
            LOG(1, "Could not find <image> element for the image layer.\n");
            return false;
        }
        imgLayer->setImagePath(xmlImage->Attribute("source"));

        // Save image layer
        map.addLayer(imgLayer);

        xmlImgLayer = xmlImgLayer->NextSiblingElement("imagelayer");
    }

    return true;
}
Example #28
0
bool BaseLayer::initTileMap(int ID)//初始化地图
{
    bool bRet = false;
    
    do {
        m_tileParallaxNode = TileParallaxNode::createWithID(ID);
        
        CCAssert(m_tileParallaxNode != NULL, "TileParallaxNode cannot be NULL");
        CC_BREAK_IF(!m_tileParallaxNode);
        
        m_tileParallaxNode->retain();
        addChild(m_tileParallaxNode, 0, -6);
        
        
        TMXTiledMap* pTileMap = m_tileParallaxNode->getTileMap();
        TMXLayer *tmxLayer;
        tmxLayer = pTileMap->getLayer("ObjectsFar");
        CCAssert(tmxLayer != NULL, "ObjectsFar layer not found!");
        tmxLayer->retain();
        tmxLayer->removeFromParentAndCleanup(false);
        m_objectsFar->addChild(tmxLayer, 0, OBJECT_FAR_TAG);
        addChild(m_objectsFar);
        tmxLayer->release();
        
        tmxLayer = pTileMap->getLayer("ObjectsMiddle");
        CCAssert(tmxLayer != NULL, "ObjectsMiddle layer not found!");
        tmxLayer->retain();
        tmxLayer->removeFromParentAndCleanup(false);
        m_objectsMiddle->addChild(tmxLayer);
        tmxLayer->setTag(OBJECT_MIDDLE_TAG);
        addChild(m_objectsMiddle, CaculateObjectMiddleOrder(),OBJECT_MIDDLE_TAG);
        //reorderTMXLayer(tmxLayer);//这样渲染批次有点高
        tmxLayer->release();
        
        tmxLayer = pTileMap->getLayer("ObjectsNear");
        CCAssert(tmxLayer != NULL, "ObjectsNear layer not found!");
        tmxLayer->retain();
        tmxLayer->removeFromParentAndCleanup(false);
        m_objectsNear->addChild(tmxLayer,0,OBJECT_NEAR_TAG);
        addChild(m_objectsNear);
        tmxLayer->release();
        
        reorderChild(m_objectsFar, 0);//reorder the layer
        reorderChild(m_objectsNear, DataManager::getInstance()->getMaxZorder() + 1);
        
        
        bRet = true;
    } while (0);
    
    return  bRet;
    
}
Example #29
0
void TMXSceneEncoder::writeSoloTileset(const TMXMap& map, const gameplay::TMXTileSet& tmxTileset, const TMXLayer& tileset, std::ofstream& file, unsigned int resultOnlyForTileset)
{
    WRITE_PROPERTY_BLOCK_START("tileset");

    // Write tile path
    WRITE_PROPERTY_BLOCK_VALUE("path", tmxTileset.getImagePath());
    WRITE_PROPERTY_NEWLINE();

    // Write tile size
    //XXX if tile sizes are incorrect, make sure to update TMXLayer::getTileStart too
    char buffer[BUFFER_SIZE];
    snprintf(buffer, BUFFER_SIZE, "tileWidth = %u", tmxTileset.getMaxTileWidth());
    WRITE_PROPERTY_DIRECT(buffer);
    snprintf(buffer, BUFFER_SIZE, "tileHeight = %u", tmxTileset.getMaxTileHeight());
    WRITE_PROPERTY_DIRECT(buffer);

    // Write tileset size
    snprintf(buffer, BUFFER_SIZE, "columns = %u", tileset.getWidth());
    WRITE_PROPERTY_DIRECT(buffer);
    snprintf(buffer, BUFFER_SIZE, "rows = %u", tileset.getHeight());
    WRITE_PROPERTY_DIRECT(buffer);
    WRITE_PROPERTY_NEWLINE();

    // Write opacity
    if (tileset.getOpacity() < 1.0f)
    {
        snprintf(buffer, BUFFER_SIZE, "opacity = %f", tileset.getOpacity());
        WRITE_PROPERTY_DIRECT(buffer);
        WRITE_PROPERTY_NEWLINE();
    }

    // Write tiles
    unsigned int tilesetHeight = tileset.getHeight();
    unsigned int tilesetWidth = tileset.getWidth();
    for (unsigned int y = 0; y < tilesetHeight; y++)
    {
        bool tilesWritten = false;
        for (unsigned int x = 0; x < tilesetWidth; x++)
        {
            Vector2 startPos = tileset.getTileStart(x, y, map, resultOnlyForTileset);
            if (startPos.x < 0 || startPos.y < 0)
            {
                continue;
            }

            tilesWritten = true;
            WRITE_PROPERTY_BLOCK_START("tile");
            snprintf(buffer, BUFFER_SIZE, "cell = %u, %u", x, y);
            WRITE_PROPERTY_DIRECT(buffer);
            snprintf(buffer, BUFFER_SIZE, "source = %u, %u", static_cast<unsigned int>(startPos.x), static_cast<unsigned int>(startPos.y));
            WRITE_PROPERTY_DIRECT(buffer);
            WRITE_PROPERTY_BLOCK_END();
        }
        if (tilesWritten && ((y + 1) != tilesetHeight))
        {
            WRITE_PROPERTY_NEWLINE();
        }
    }

    WRITE_PROPERTY_BLOCK_END();
}
Example #30
0
void GUICache::cacheAllLayers(Map* map)
{
    // Clear
    _mobs.clear();
    _obstacles.clear();
    _effects.clear();

    // Sprites
    TMXLayer *spritesLayer = map->getTiledMap()->layerNamed("sprites");

    // Obstacles
    TMXLayer *obstaclesLayer = map->getTiledMap()->layerNamed("obstacles");

    // Effects
    TMXLayer *effectsLayer = map->getTiledMap()->layerNamed("effects");

    // Portals
    TMXLayer *portalsLayer = map->getTiledMap()->layerNamed("portals");

    // Init obstacles, mobs and effects structure
    for(int ix = 0; ix < map->getWidth(); ix++)
    {
        for(int iy = 0; iy < map->getHeight(); iy++)
        {
            Point point = ccp(ix, iy);
            if(obstaclesLayer->tileGIDAt( point ) != 0)
            {
                int position = map->getWidth() * iy + ix;
                _obstacles[ position ] = obstaclesLayer->tileAt( point );
            }

            if(spritesLayer->tileGIDAt( point ) != 0)
            {
                int position = map->getWidth() * (map->getHeight() - iy - 1) + ix;
                _mobs[ position ] = spritesLayer->tileAt( point );
            }

            if(effectsLayer->tileGIDAt( point ) != 0)
            {
                int position = map->getWidth() * iy + ix;
                _effects[ position ] = effectsLayer->tileAt( point );
            }

            if(portalsLayer->tileGIDAt( point ) != 0)
            {
                int position = map->getWidth() * iy + ix;
                _portals[ position ] = portalsLayer->tileAt( point );
            }

        }
    }
}