Merge pull request #182 from halx99/leve-one-tmxlayermap

Only leave one TMXLayer & TMXTileMap

Author: halx99

cocos/2d/CCFastTMXLayer.cpp

@@ -93,6 +93,8 @@ bool FastTMXLayer::initWithTilesetInfo(TMXTilesetInfo *tilesetInfo, TMXLayerInfo
     // mapInfo
     _mapTileSize = mapInfo->getTileSize();
     _layerOrientation = mapInfo->getOrientation();
+    _staggerAxis = mapInfo->getStaggerAxis();
+    _staggerIndex = mapInfo->getStaggerIndex();
 
     // offset (after layer orientation is set);
     Vec2 offset = this->calculateLayerOffset(layerInfo->_offset);
@@ -321,6 +323,57 @@ void FastTMXLayer::setupTiles()
 
     _screenTileCount = (int)(_screenGridSize.width * _screenGridSize.height);
 
+    if (!_tileSet->_animationInfo.empty()) {
+        /// FastTMXLayer: anim support
+        for (int y = 0; y < _layerSize.height; y++)
+        {
+            for (int x = 0; x < _layerSize.width; x++)
+            {
+                int newX = x;
+                // fix correct render ordering in Hexagonal maps when stagger axis == x
+                if (_staggerAxis == TMXStaggerAxis_X && _layerOrientation == TMXOrientationHex)
+                {
+                    if (_staggerIndex == TMXStaggerIndex_Odd)
+                    {
+                        if (x >= _layerSize.width / 2)
+                            newX = (x - std::ceil(_layerSize.width / 2)) * 2 + 1;
+                        else
+                            newX = x * 2;
+                    }
+                    else {
+                        // TMXStaggerIndex_Even
+                        if (x >= static_cast<int>(_layerSize.width / 2))
+                            newX = (x - static_cast<int>(_layerSize.width / 2)) * 2;
+                        else
+                            newX = x * 2 + 1;
+                    }
+                }
+
+                int pos = static_cast<int>(newX + _layerSize.width * y);
+                int gid = _tiles[pos];
+
+                // gid are stored in little endian.
+                // if host is big endian, then swap
+                //if( o == CFByteOrderBigEndian )
+                //    gid = CFSwapInt32( gid );
+                /* We support little endian.*/
+
+                // FIXME:: gid == 0 --> empty tile
+                if (gid != 0)
+                {
+                    if (_tileSet->_animationInfo.find(gid) != _tileSet->_animationInfo.end())
+                    {
+                        _animTileCoord[gid].push_back(Vec2(newX, y));
+                    }
+                }
+            }
+        }
+
+        if (hasTileAnimation())
+        {
+            _tileAnimManager = new TMXTileAnimManager(this);
+        }
+    }
 }
 
 Mat4 FastTMXLayer::tileToNodeTransform()
@@ -910,5 +963,97 @@ std::string FastTMXLayer::getDescription() const
     return StringUtils::format("<FastTMXLayer | tag = %d, size = %d,%d>", _tag, (int)_mapTileSize.width, (int)_mapTileSize.height);
 }
 
+TMXTileAnimManager::TMXTileAnimManager(FastTMXLayer* layer)
+{
+    _layer = layer;
+    for (const auto& p : *_layer->getAnimTileCoord())
+    {
+        for (auto tilePos : p.second)
+        {
+            _tasks.pushBack(TMXTileAnimTask::create(_layer, _layer->getTileSet()->_animationInfo.at(p.first), tilePos));
+        }
+    }
+}
+
+TMXTileAnimManager* TMXTileAnimManager::create(FastTMXLayer* layer)
+{
+    TMXTileAnimManager* ret = new (std::nothrow) TMXTileAnimManager(layer);
+    if (ret)
+    {
+        ret->autorelease();
+        return ret;
+    }
+    CC_SAFE_DELETE(ret);
+    return nullptr;
+}
+
+void TMXTileAnimManager::startAll()
+{
+    if (_started || _tasks.empty())
+        return;
+    _started = true;
+    for (auto& task : _tasks)
+    {
+        task->start();
+    }
+}
+
+void TMXTileAnimManager::stopAll()
+{
+    if (!_started)
+        return;
+    _started = false;
+    for (auto& task : _tasks)
+    {
+        task->stop();
+    }
+}
+
+TMXTileAnimTask::TMXTileAnimTask(FastTMXLayer* layer, TMXTileAnimInfo* animation, const Vec2& tilePos)
+{
+    _layer = layer;
+    _animation = animation;
+    _frameCount = static_cast<uint32_t>(_animation->_frames.size());
+    _tilePosition = tilePos;
+    std::stringstream ss;
+    ss << "TickAnimOnTilePos(" << _tilePosition.x << "," << _tilePosition.y << ")";
+    _key = ss.str();
+}
+
+void TMXTileAnimTask::tickAndScheduleNext(float dt)
+{
+    setCurrFrame();
+    _layer->getParent()->scheduleOnce(CC_CALLBACK_1(TMXTileAnimTask::tickAndScheduleNext, this), _animation->_frames[_currentFrame]._duration / 1000.0f, _key);
+}
+
+void TMXTileAnimTask::start()
+{
+    _isRunning = true;
+    tickAndScheduleNext(0.0f);
+}
+
+void TMXTileAnimTask::stop()
+{
+    _isRunning = false;
+    _layer->getParent()->unschedule(_key);
+}
+
+void TMXTileAnimTask::setCurrFrame()
+{
+    _layer->setTileGID(_animation->_frames[_currentFrame]._tileID, _tilePosition);
+    _currentFrame = (_currentFrame + 1) % _frameCount;
+}
+
+TMXTileAnimTask* TMXTileAnimTask::create(FastTMXLayer* layer, TMXTileAnimInfo* animation, const Vec2& tilePos)
+{
+    TMXTileAnimTask* ret = new (std::nothrow) TMXTileAnimTask(layer, animation, tilePos);
+    if (ret)
+    {
+        ret->autorelease();
+        return ret;
+    }
+    CC_SAFE_DELETE(ret);
+    return nullptr;
+}
 
 NS_CC_END

cocos/2d/CCFastTMXLayer.h

@@ -37,6 +37,7 @@ NS_CC_BEGIN
 class TMXMapInfo;
 class TMXLayerInfo;
 class TMXTilesetInfo;
+class TMXTileAnimManager;
 class Texture2D;
 class Sprite;
 
@@ -275,10 +276,29 @@ class CC_DLL FastTMXLayer : public Node
     virtual void draw(Renderer *renderer, const Mat4& transform, uint32_t flags) override;
     void removeChild(Node* child, bool cleanup = true) override;
 
+    /** Map from gid of animated tile to its instance.
+     *
+     * @return Map from gid of animated tile to its instance.
+     */
+    const std::unordered_map<uint32_t, std::vector<Vec2>>* getAnimTileCoord() {
+        return &_animTileCoord;
+    }
+
+    bool hasTileAnimation() const {
+        return !_animTileCoord.empty();
+    }
+
+    TMXTileAnimManager* getTileAnimManager() const {
+        return _tileAnimManager;
+    }
+
+CC_CONSTRUCTOR_ACCESS:
+    bool initWithTilesetInfo(TMXTilesetInfo* tilesetInfo, TMXLayerInfo* layerInfo, TMXMapInfo* mapInfo);
+
 protected:
     virtual void setOpacity(uint8_t opacity) override;
 
-    bool initWithTilesetInfo(TMXTilesetInfo *tilesetInfo, TMXLayerInfo *layerInfo, TMXMapInfo *mapInfo);
+
     void updateTiles(const Rect& culledRect);
     Vec2 calculateLayerOffset(const Vec2& offset);
 
@@ -315,9 +335,16 @@ class CC_DLL FastTMXLayer : public Node
     TMXTilesetInfo* _tileSet = nullptr;
     /** Layer orientation, which is the same as the map orientation */
     int _layerOrientation = FAST_TMX_ORIENTATION_ORTHO;
+    int _staggerAxis = TMXStaggerAxis_Y;
+    int _staggerIndex = TMXStaggerIndex_Even;
     /** properties from the layer. They can be added using Tiled */
     ValueMap _properties;
 
+    /** map from gid of animated tile to its instance. Also useful for optimization*/
+    std::unordered_map<uint32_t, std::vector<Vec2>> _animTileCoord;
+    /** pointer to the tile animation manager of this layer */
+    TMXTileAnimManager* _tileAnimManager = nullptr;
+
     Texture2D *_texture = nullptr;
 
     /** container for sprite children. map<index, pair<sprite, gid> > */
@@ -356,6 +383,69 @@ class CC_DLL FastTMXLayer : public Node
     backend::UniformLocation _alphaValueLocation;
 };
 
+/** @brief TMXTileAnimTask represents the frame-tick task of an animated tile.
+ * It is a assistant class for TMXTileAnimTicker.
+ */
+class CC_DLL TMXTileAnimTask : public Ref
+{
+public:
+    TMXTileAnimTask(FastTMXLayer* layer, TMXTileAnimInfo* animation, const Vec2& tilePos);
+    static TMXTileAnimTask* create(FastTMXLayer* layer, TMXTileAnimInfo* animation, const Vec2& tilePos);
+    /** start the animation task */
+    void start();
+    /** stop the animation task */
+    void stop();
+    bool isRunning() const {
+        return _isRunning;
+    }
+
+protected:
+    /** set texture of tile to current frame */
+    void setCurrFrame();
+    /** tick to next frame and schedule next tick */
+    void tickAndScheduleNext(float dt);
+
+    bool _isRunning = false;
+    /** key of schedule task for specific animated tile */
+    std::string _key;
+    FastTMXLayer* _layer = nullptr;
+    /** position of the animated tile */
+    Vec2 _tilePosition;
+    /** AnimationInfo on this tile */
+    TMXTileAnimInfo* _animation = nullptr;
+    /** Index of the frame that should be drawn currently */
+    uint32_t _currentFrame = 0;
+    uint32_t _frameCount = 0;
+};
+
+/** @brief TMXTileAnimManager controls all tile animation of a layer.
+ */
+class CC_DLL TMXTileAnimManager : public Ref
+{
+public:
+    static TMXTileAnimManager* create(FastTMXLayer* layer);
+    explicit TMXTileAnimManager(FastTMXLayer* layer);
+
+    /** start all tile animations */
+    void startAll();
+    /** stop all tile animations */
+    void stopAll();
+
+    /** get vector of tasks */
+    const Vector<TMXTileAnimTask*>& getTasks() const {
+        return _tasks;
+    }
+
+protected:
+    bool _started = false;
+    /** vector contains all tasks of this layer */
+    Vector<TMXTileAnimTask*> _tasks;
+    FastTMXLayer* _layer = nullptr;
+};
+
+// @API compatible
+typedef FastTMXLayer TMXLayer;
+
 // end of tilemap_parallax_nodes group
 /// @}
 NS_CC_END

cocos/2d/CCFastTMXTiledMap.cpp

@@ -72,6 +72,8 @@ bool FastTMXTiledMap::initWithTMXFile(const std::string& tmxFile)
     CCASSERT( !mapInfo->getTilesets().empty(), "FastTMXTiledMap: Map not found. Please check the filename.");
     buildWithMapInfo(mapInfo);
 
+    _tmxFile = tmxFile;
+
     return true;
 }
 
@@ -192,6 +194,8 @@ void FastTMXTiledMap::buildWithMapInfo(TMXMapInfo* mapInfo)
             idx++;
         }
     }
+
+    _layerCount = idx;
 }
 
 // public
@@ -257,4 +261,22 @@ std::string FastTMXTiledMap::getDescription() const
     return StringUtils::format("<FastTMXTiledMap | Tag = %d, Layers = %d", _tag, static_cast<int>(_children.size()));
 }
 
+void FastTMXTiledMap::setTileAnimEnabled(bool enabled)
+{
+    for (auto& child : _children)
+    {
+        FastTMXLayer* layer = dynamic_cast<FastTMXLayer*>(child);
+        if (layer)
+        {
+            if (layer->hasTileAnimation())
+            {
+                if (enabled)
+                    layer->getTileAnimManager()->startAll();
+                else
+                    layer->getTileAnimManager()->stopAll();
+            }
+        }
+    }
+}
+
 NS_CC_END

cocos/2d/CCFastTMXTiledMap.h

@@ -201,7 +201,18 @@ class CC_DLL FastTMXTiledMap : public Node
 
     virtual std::string getDescription() const override;
 
-protected:
+    /** Set all tile animations enabled or not.
+     *  animations are not enabled by default
+     */
+    void setTileAnimEnabled(bool enabled);
+
+    CC_DEPRECATED_ATTRIBUTE int getLayerNum() const { return getLayerCount(); }
+
+    int getLayerCount() const { return _layerCount; }
+
+    const std::string& getResourceFile() const { return _tmxFile; }
+
+CC_CONSTRUCTOR_ACCESS:
     /**
      * @js ctor
      */
@@ -218,6 +229,7 @@ class CC_DLL FastTMXTiledMap : public Node
     /** initializes a TMX Tiled Map with a TMX formatted XML string and a path to TMX resources */
     bool initWithXML(const std::string& tmxString, const std::string& resourcePath);
 
+protected:
     FastTMXLayer * parseLayer(TMXLayerInfo *layerInfo, TMXMapInfo *mapInfo);
     TMXTilesetInfo * tilesetForLayer(TMXLayerInfo *layerInfo, TMXMapInfo *mapInfo);
     void buildWithMapInfo(TMXMapInfo* mapInfo);
@@ -236,13 +248,18 @@ class CC_DLL FastTMXTiledMap : public Node
     //! tile properties
     ValueMapIntKey _tileProperties;
 
+    int _layerCount = 0;
+
+    std::string _tmxFile;
 private:
     CC_DISALLOW_COPY_AND_ASSIGN(FastTMXTiledMap);
 
 };
 
 // end of tilemap_parallax_nodes group
 /** @} */
-    
+
+// @API compatible
+typedef FastTMXTiledMap TMXTiledMap;
 
 NS_CC_END