var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var es;
(function (es) {
    var TiledMapRenderer = (function (_super) {
        __extends(TiledMapRenderer, _super);
        function TiledMapRenderer(tiledMap, collisionLayerName, shouldCreateColliders) {
            if (collisionLayerName === void 0) { collisionLayerName = null; }
            if (shouldCreateColliders === void 0) { shouldCreateColliders = true; }
            var _this = _super.call(this) || this;
            _this.physicsLayer = new es.Ref(1 << 0);
            _this.toContainer = false;
            _this.tiledMap = tiledMap;
            _this._shouldCreateColliders = shouldCreateColliders;
            _this.displayObject = new egret.DisplayObjectContainer();
            if (collisionLayerName) {
                _this.collisionLayer = tiledMap.tileLayers.find(function (layer) { return layer.name == collisionLayerName; });
            }
            return _this;
        }
        Object.defineProperty(TiledMapRenderer.prototype, "width", {
            get: function () {
                return this.tiledMap.width * this.tiledMap.tileWidth;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TiledMapRenderer.prototype, "height", {
            get: function () {
                return this.tiledMap.height * this.tiledMap.tileHeight;
            },
            enumerable: true,
            configurable: true
        });
        TiledMapRenderer.prototype.setLayerToRender = function (layerName) {
            this.layerIndicesToRender = [];
            this.layerIndicesToRender[0] = this.getLayerIndex(layerName);
        };
        TiledMapRenderer.prototype.setLayersToRender = function () {
            var layerNames = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                layerNames[_i] = arguments[_i];
            }
            this.layerIndicesToRender = [];
            for (var i = 0; i < layerNames.length; i++)
                this.layerIndicesToRender[i] = this.getLayerIndex(layerNames[i]);
        };
        TiledMapRenderer.prototype.getLayerIndex = function (layerName) {
            var index = 0;
            var layerType = this.tiledMap.getLayer(layerName);
            for (var layer in this.tiledMap.layers) {
                if (this.tiledMap.layers.hasOwnProperty(layer) &&
                    this.tiledMap.layers[layer] == layerType) {
                    return index;
                }
            }
            return -1;
        };
        TiledMapRenderer.prototype.getRowAtWorldPosition = function (yPos) {
            yPos -= this.entity.transform.position.y + this._localOffset.y;
            return this.tiledMap.worldToTilePositionY(yPos);
        };
        TiledMapRenderer.prototype.getColumnAtWorldPosition = function (xPos) {
            xPos -= this.entity.transform.position.x + this._localOffset.x;
            return this.tiledMap.worldToTilePositionX(xPos);
        };
        TiledMapRenderer.prototype.onEntityTransformChanged = function (comp) {
            if (this._shouldCreateColliders && comp == transform.Component.position) {
                this.removeColliders();
                this.addColliders();
            }
        };
        TiledMapRenderer.prototype.onAddedToEntity = function () {
            this.addColliders();
        };
        TiledMapRenderer.prototype.onRemovedFromEntity = function () {
            this.removeColliders();
        };
        TiledMapRenderer.prototype.update = function () {
            this.tiledMap.update();
        };
        TiledMapRenderer.prototype.render = function (camera) {
            this.sync(camera);
            if (!this.layerIndicesToRender) {
                es.TiledRendering.renderMap(this.tiledMap, !this.toContainer ? this.displayObject : null, es.Vector2.add(this.entity.transform.position, this._localOffset), this.transform.scale, this.renderLayer);
            }
            else {
                for (var i = 0; i < this.tiledMap.layers.length; i++) {
                    if (this.tiledMap.layers[i].visible && this.layerIndicesToRender.contains(i))
                        es.TiledRendering.renderLayerRenderCamera(this.tiledMap.layers[i], !this.toContainer ? this.displayObject : null, es.Vector2.add(this.entity.transform.position, this._localOffset), this.transform.scale, this.renderLayer, camera.bounds);
                }
            }
            if (!this.toContainer) {
                this.displayObject.cacheAsBitmap = true;
                this.toContainer = true;
            }
        };
        TiledMapRenderer.prototype.addColliders = function () {
            if (!this.collisionLayer || !this._shouldCreateColliders)
                return;
            var collisionRects = this.collisionLayer.getCollisionRectangles();
            this._colliders = [];
            for (var i = 0; i < collisionRects.length; i++) {
                var collider = new es.BoxCollider(collisionRects[i].x + this._localOffset.x, collisionRects[i].y + this._localOffset.y, collisionRects[i].width, collisionRects[i].height);
                collider.physicsLayer = this.physicsLayer;
                collider.entity = this.entity;
                this._colliders[i] = collider;
                es.Physics.addCollider(collider);
            }
        };
        TiledMapRenderer.prototype.removeColliders = function () {
            if (this._colliders == null)
                return;
            for (var _i = 0, _a = this._colliders; _i < _a.length; _i++) {
                var collider = _a[_i];
                es.Physics.removeCollider(collider);
            }
            this._colliders = null;
        };
        return TiledMapRenderer;
    }(es.RenderableComponent));
    es.TiledMapRenderer = TiledMapRenderer;
})(es || (es = {}));
var es;
(function (es) {
    var TmxGroup = (function () {
        function TmxGroup() {
        }
        return TmxGroup;
    }());
    es.TmxGroup = TmxGroup;
})(es || (es = {}));
var es;
(function (es) {
    var TmxImageLayer = (function () {
        function TmxImageLayer() {
        }
        return TmxImageLayer;
    }());
    es.TmxImageLayer = TmxImageLayer;
})(es || (es = {}));
var es;
(function (es) {
    var TmxLayer = (function () {
        function TmxLayer() {
        }
        Object.defineProperty(TmxLayer.prototype, "offset", {
            get: function () {
                return new es.Vector2(this.offsetX, this.offsetY);
            },
            enumerable: true,
            configurable: true
        });
        TmxLayer.prototype.getTileWithGid = function (gid) {
            for (var i = 0; i < this.tiles.length; i++) {
                if (this.tiles[i] && this.tiles[i].gid == gid)
                    return this.tiles[i];
            }
            return null;
        };
        TmxLayer.prototype.getTile = function (x, y) {
            return this.tiles[x + y * this.width];
        };
        TmxLayer.prototype.getCollisionRectangles = function () {
            var checkedIndexes = new Array(this.tiles.length);
            var rectangles = [];
            var startCol = -1;
            var index = -1;
            for (var y = 0; y < this.map.height; y++) {
                for (var x = 0; x < this.map.width; x++) {
                    index = y * this.map.width + x;
                    var tile = this.getTile(x, y);
                    if (tile && !checkedIndexes[index]) {
                        if (startCol < 0)
                            startCol = x;
                        checkedIndexes[index] = true;
                    }
                    else if (!tile || checkedIndexes[index] == true) {
                        if (startCol >= 0) {
                            rectangles.push(this.findBoundsRect(startCol, x, y, checkedIndexes));
                            startCol = -1;
                        }
                    }
                }
                if (startCol >= 0) {
                    rectangles.push(this.findBoundsRect(startCol, this.map.width, y, checkedIndexes));
                    startCol = -1;
                }
            }
            return rectangles;
        };
        TmxLayer.prototype.findBoundsRect = function (startX, endX, startY, checkedIndexes) {
            var index = -1;
            for (var y = startY + 1; y < this.map.height; y++) {
                for (var x = startX; x < endX; x++) {
                    index = y * this.map.width + x;
                    var tile = this.getTile(x, y);
                    if (!tile || checkedIndexes[index]) {
                        for (var _x = startX; _x < x; _x++) {
                            index = y * this.map.width + _x;
                            checkedIndexes[index] = false;
                        }
                        return new es.Rectangle(startX * this.map.tileWidth, startY * this.map.tileHeight, (endX - startX) * this.map.tileWidth, (y - startY) * this.map.tileHeight);
                    }
                    checkedIndexes[index] = true;
                }
            }
            return new es.Rectangle(startX * this.map.tileWidth, startY * this.map.tileHeight, (endX - startX) * this.map.tileWidth, (this.map.height - startY) * this.map.tileHeight);
        };
        return TmxLayer;
    }());
    es.TmxLayer = TmxLayer;
    var TmxLayerTile = (function () {
        function TmxLayerTile(map, id, x, y) {
            this.x = x;
            this.y = y;
            var rawGid = id;
            var flip;
            flip = (rawGid & TmxLayerTile.FLIPPED_HORIZONTALLY_FLAG) != 0;
            this.horizontalFlip = flip;
            flip = (rawGid & TmxLayerTile.FLIPPED_VERTICALLY_FLAG) != 0;
            this.verticalFlip = flip;
            rawGid &= ~(TmxLayerTile.FLIPPED_HORIZONTALLY_FLAG | TmxLayerTile.FLIPPED_VERTICALLY_FLAG);
            this.gid = Math.floor(rawGid);
            this.tileset = map.getTilesetForTileGid(this.gid);
        }
        Object.defineProperty(TmxLayerTile.prototype, "position", {
            get: function () {
                return new es.Vector2(this.x, this.y);
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TmxLayerTile.prototype, "tilesetTile", {
            get: function () {
                if (!this._tilesetTileIndex) {
                    this._tilesetTileIndex = -1;
                    if (this.tileset.firstGid <= this.gid) {
                        var tilesetTile = this.tileset.tiles.get(this.gid - this.tileset.firstGid);
                        if (tilesetTile) {
                            this._tilesetTileIndex = this.gid - this.tileset.firstGid;
                        }
                    }
                }
                if (this._tilesetTileIndex < 0)
                    return null;
                return this.tileset.tiles.get(this._tilesetTileIndex);
            },
            enumerable: true,
            configurable: true
        });
        TmxLayerTile.FLIPPED_HORIZONTALLY_FLAG = 0x80000000;
        TmxLayerTile.FLIPPED_VERTICALLY_FLAG = 0x40000000;
        return TmxLayerTile;
    }());
    es.TmxLayerTile = TmxLayerTile;
})(es || (es = {}));
var es;
(function (es) {
    var TmxDocument = (function () {
        function TmxDocument() {
            this.tmxDirectory = "resource/assets/";
        }
        return TmxDocument;
    }());
    es.TmxDocument = TmxDocument;
    var TmxImage = (function () {
        function TmxImage() {
        }
        TmxImage.prototype.dispose = function () {
            if (this.bitmap) {
                this.bitmap.dispose();
                this.bitmap = null;
            }
        };
        return TmxImage;
    }());
    es.TmxImage = TmxImage;
})(es || (es = {}));
var es;
(function (es) {
    var TmxMap = (function (_super) {
        __extends(TmxMap, _super);
        function TmxMap() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        Object.defineProperty(TmxMap.prototype, "worldWidth", {
            get: function () {
                return this.width * this.tileWidth;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TmxMap.prototype, "worldHeight", {
            get: function () {
                return this.height * this.tileHeight;
            },
            enumerable: true,
            configurable: true
        });
        Object.defineProperty(TmxMap.prototype, "requiresLargeTileCulling", {
            get: function () {
                return this.maxTileHeight > this.tileHeight || this.maxTileWidth > this.tileWidth;
            },
            enumerable: true,
            configurable: true
        });
        TmxMap.prototype.getTilesetForTileGid = function (gid) {
            if (gid == 0)
                return null;
            for (var i = this.tilesets.length - 1; i >= 0; i--) {
                if (this.tilesets[i].firstGid <= gid)
                    return this.tilesets[i];
            }
            console.error("tile gid" + gid + "\u672A\u5728\u4EFB\u4F55tileset\u4E2D\u627E\u5230");
        };
        TmxMap.prototype.worldToTilePositionX = function (x, clampToTilemapBounds) {
            if (clampToTilemapBounds === void 0) { clampToTilemapBounds = true; }
            var tileX = Math.floor(x / this.tileWidth);
            if (!clampToTilemapBounds)
                return tileX;
            return es.MathHelper.clamp(tileX, 0, this.width - 1);
        };
        TmxMap.prototype.worldToTilePositionY = function (y, clampToTilemapBounds) {
            if (clampToTilemapBounds === void 0) { clampToTilemapBounds = true; }
            var tileY = Math.floor(y / this.tileHeight);
            if (!clampToTilemapBounds)
                return tileY;
            return es.MathHelper.clamp(tileY, 0, this.height - 1);
        };
        TmxMap.prototype.getLayer = function (name) {
            return this.layers[name];
        };
        TmxMap.prototype.update = function () {
            this.tilesets.forEach(function (tileset) { tileset.update(); });
        };
        TmxMap.prototype.dispose = function (disposing) {
            if (disposing === void 0) { disposing = true; }
            if (!this._isDisposed) {
                if (disposing) {
                    this.tilesets.forEach(function (tileset) { if (tileset.image)
                        tileset.image.dispose(); });
                    this.imageLayers.forEach(function (layer) { if (layer.image)
                        layer.image.dispose(); });
                }
                this._isDisposed = true;
            }
        };
        return TmxMap;
    }(es.TmxDocument));
    es.TmxMap = TmxMap;
    var OrientationType;
    (function (OrientationType) {
        OrientationType[OrientationType["unknown"] = 0] = "unknown";
        OrientationType[OrientationType["orthogonal"] = 1] = "orthogonal";
        OrientationType[OrientationType["isometric"] = 2] = "isometric";
        OrientationType[OrientationType["staggered"] = 3] = "staggered";
        OrientationType[OrientationType["hexagonal"] = 4] = "hexagonal";
    })(OrientationType = es.OrientationType || (es.OrientationType = {}));
    var StaggerAxisType;
    (function (StaggerAxisType) {
        StaggerAxisType[StaggerAxisType["x"] = 0] = "x";
        StaggerAxisType[StaggerAxisType["y"] = 1] = "y";
    })(StaggerAxisType = es.StaggerAxisType || (es.StaggerAxisType = {}));
    var StaggerIndexType;
    (function (StaggerIndexType) {
        StaggerIndexType[StaggerIndexType["odd"] = 0] = "odd";
        StaggerIndexType[StaggerIndexType["even"] = 1] = "even";
    })(StaggerIndexType = es.StaggerIndexType || (es.StaggerIndexType = {}));
    var RenderOrderType;
    (function (RenderOrderType) {
        RenderOrderType[RenderOrderType["rightDown"] = 0] = "rightDown";
        RenderOrderType[RenderOrderType["rightUp"] = 1] = "rightUp";
        RenderOrderType[RenderOrderType["leftDown"] = 2] = "leftDown";
        RenderOrderType[RenderOrderType["leftUp"] = 3] = "leftUp";
    })(RenderOrderType = es.RenderOrderType || (es.RenderOrderType = {}));
})(es || (es = {}));
var es;
(function (es) {
    var TmxObjectGroup = (function () {
        function TmxObjectGroup() {
        }
        return TmxObjectGroup;
    }());
    es.TmxObjectGroup = TmxObjectGroup;
    var TmxObject = (function () {
        function TmxObject() {
            this.shape = new egret.Shape();
            this.textField = new egret.TextField();
        }
        return TmxObject;
    }());
    es.TmxObject = TmxObject;
    var TmxText = (function () {
        function TmxText() {
        }
        return TmxText;
    }());
    es.TmxText = TmxText;
    var TmxAlignment = (function () {
        function TmxAlignment() {
        }
        return TmxAlignment;
    }());
    es.TmxAlignment = TmxAlignment;
    var TmxObjectType;
    (function (TmxObjectType) {
        TmxObjectType[TmxObjectType["basic"] = 0] = "basic";
        TmxObjectType[TmxObjectType["point"] = 1] = "point";
        TmxObjectType[TmxObjectType["tile"] = 2] = "tile";
        TmxObjectType[TmxObjectType["ellipse"] = 3] = "ellipse";
        TmxObjectType[TmxObjectType["polygon"] = 4] = "polygon";
        TmxObjectType[TmxObjectType["polyline"] = 5] = "polyline";
        TmxObjectType[TmxObjectType["text"] = 6] = "text";
    })(TmxObjectType = es.TmxObjectType || (es.TmxObjectType = {}));
    var DrawOrderType;
    (function (DrawOrderType) {
        DrawOrderType[DrawOrderType["unkownOrder"] = -1] = "unkownOrder";
        DrawOrderType[DrawOrderType["TopDown"] = 0] = "TopDown";
        DrawOrderType[DrawOrderType["IndexOrder"] = 1] = "IndexOrder";
    })(DrawOrderType = es.DrawOrderType || (es.DrawOrderType = {}));
    var TmxHorizontalAlignment;
    (function (TmxHorizontalAlignment) {
        TmxHorizontalAlignment[TmxHorizontalAlignment["left"] = 0] = "left";
        TmxHorizontalAlignment[TmxHorizontalAlignment["center"] = 1] = "center";
        TmxHorizontalAlignment[TmxHorizontalAlignment["right"] = 2] = "right";
        TmxHorizontalAlignment[TmxHorizontalAlignment["justify"] = 3] = "justify";
    })(TmxHorizontalAlignment = es.TmxHorizontalAlignment || (es.TmxHorizontalAlignment = {}));
    var TmxVerticalAlignment;
    (function (TmxVerticalAlignment) {
        TmxVerticalAlignment[TmxVerticalAlignment["top"] = 0] = "top";
        TmxVerticalAlignment[TmxVerticalAlignment["center"] = 1] = "center";
        TmxVerticalAlignment[TmxVerticalAlignment["bottom"] = 2] = "bottom";
    })(TmxVerticalAlignment = es.TmxVerticalAlignment || (es.TmxVerticalAlignment = {}));
})(es || (es = {}));
var es;
(function (es) {
    var TiledMapLoader = (function () {
        function TiledMapLoader() {
        }
        TiledMapLoader.loadTmxMap = function (map, filePath) {
            var xMap = RES.getRes(filePath);
            return this.loadTmxMapData(map, xMap, RES.getResourceInfo(filePath));
        };
        TiledMapLoader.loadTmxMapData = function (map, xMap, info) {
            return __awaiter(this, void 0, void 0, function () {
                var _i, _a, e, tileset;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            map.version = xMap["version"];
                            map.tiledVersion = xMap["tiledversion"];
                            map.width = xMap["width"];
                            map.height = xMap["height"];
                            map.tileWidth = xMap["tilewidth"];
                            map.tileHeight = xMap["tileheight"];
                            map.hexSideLength = xMap["hexsidelength"];
                            map.orientation = this.parseOrientationType(xMap["orientation"]);
                            map.staggerAxis = this.parseStaggerAxisType(xMap["staggeraxis"]);
                            map.staggerIndex = this.parseStaggerIndexType(xMap["staggerindex"]);
                            map.renderOrder = this.parseRenderOrderType(xMap["renderorder"]);
                            map.nextObjectID = xMap["nextobjectid"];
                            map.backgroundColor = es.TmxUtils.color16ToUnit(xMap["color"]);
                            map.properties = this.parsePropertyDict(xMap["properties"]);
                            map.maxTileWidth = map.tileWidth;
                            map.maxTileHeight = map.tileHeight;
                            map.tmxDirectory = info.root + info.url.replace(".", "_").replace(info.name, "");
                            map.tilesets = [];
                            _i = 0, _a = xMap["tilesets"];
                            _b.label = 1;
                        case 1:
                            if (!(_i < _a.length)) return [3, 4];
                            e = _a[_i];
                            return [4, this.parseTmxTileset(map, e)];
                        case 2:
                            tileset = _b.sent();
                            map.tilesets.push(tileset);
                            this.updateMaxTileSizes(tileset);
                            _b.label = 3;
                        case 3:
                            _i++;
                            return [3, 1];
                        case 4:
                            map.layers = [];
                            map.tileLayers = [];
                            map.objectGroups = [];
                            map.imageLayers = [];
                            map.groups = [];
                            this.parseLayers(map, xMap, map, map.width, map.height, map.tmxDirectory);
                            return [2, map];
                    }
                });
            });
        };
        TiledMapLoader.parseLayers = function (container, xEle, map, width, height, tmxDirectory) {
            return __awaiter(this, void 0, void 0, function () {
                var _i, _a, e, layer, _b, tileLayer, objectgroup, imagelayer, newGroup;
                return __generator(this, function (_c) {
                    switch (_c.label) {
                        case 0:
                            _i = 0, _a = ObjectUtils.elements(xEle).where(function (x) {
                                return x.type == "tilelayer" || x.type == "objectgroup" || x.type == "imagelayer" || x.type == "group";
                            });
                            _c.label = 1;
                        case 1:
                            if (!(_i < _a.length)) return [3, 11];
                            e = _a[_i];
                            layer = void 0;
                            _b = e.type;
                            switch (_b) {
                                case "tilelayer": return [3, 2];
                                case "objectgroup": return [3, 3];
                                case "imagelayer": return [3, 4];
                                case "group": return [3, 6];
                            }
                            return [3, 8];
                        case 2:
                            tileLayer = this.loadTmxLayer(new es.TmxLayer(), map, e, width, height);
                            layer = tileLayer;
                            if (container instanceof es.TmxMap || container instanceof es.TmxGroup)
                                container.tileLayers.push(tileLayer);
                            return [3, 9];
                        case 3:
                            objectgroup = this.loadTmxObjectGroup(new es.TmxObjectGroup(), map, e);
                            layer = objectgroup;
                            if (container instanceof es.TmxMap || container instanceof es.TmxGroup)
                                container.objectGroups.push(objectgroup);
                            return [3, 9];
                        case 4: return [4, this.loadTmxImageLayer(new es.TmxImageLayer(), map, e, tmxDirectory)];
                        case 5:
                            imagelayer = _c.sent();
                            layer = imagelayer;
                            if (container instanceof es.TmxMap || container instanceof es.TmxGroup)
                                container.imageLayers.push(imagelayer);
                            return [3, 9];
                        case 6: return [4, this.loadTmxGroup(new es.TmxGroup(), map, e, width, height, tmxDirectory)];
                        case 7:
                            newGroup = _c.sent();
                            layer = newGroup;
                            if (container instanceof es.TmxMap || container instanceof es.TmxGroup)
                                container.groups.push(newGroup);
                            return [3, 9];
                        case 8: throw new Error("无效的操作");
                        case 9:
                            if (container instanceof es.TmxMap || container instanceof es.TmxGroup)
                                container.layers.push(layer);
                            _c.label = 10;
                        case 10:
                            _i++;
                            return [3, 1];
                        case 11: return [2];
                    }
                });
            });
        };
        TiledMapLoader.loadTmxGroup = function (group, map, xGroup, width, height, tmxDirectory) {
            return __awaiter(this, void 0, void 0, function () {
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            group.map = map;
                            group.name = xGroup["name"] != undefined ? xGroup["name"] : "";
                            group.opacity = xGroup["opacity"] != undefined ? xGroup["opacity"] : 1;
                            group.visible = xGroup["visible"] != undefined ? xGroup["visible"] : true;
                            group.offsetX = xGroup["offsetx"] != undefined ? xGroup["offsetx"] : 0;
                            group.offsetY = xGroup["offsety"] != undefined ? xGroup["offsety"] : 0;
                            group.properties = this.parsePropertyDict(xGroup["properties"]);
                            group.layers = [];
                            group.tileLayers = [];
                            group.objectGroups = [];
                            group.imageLayers = [];
                            group.groups = [];
                            return [4, this.parseLayers(group, xGroup, map, width, height, tmxDirectory)];
                        case 1:
                            _a.sent();
                            return [2, group];
                    }
                });
            });
        };
        TiledMapLoader.loadTmxImageLayer = function (layer, map, xImageLayer, tmxDirectory) {
            return __awaiter(this, void 0, void 0, function () {
                var xImage, _a;
                return __generator(this, function (_b) {
                    switch (_b.label) {
                        case 0:
                            layer.map = map;
                            layer.name = xImageLayer["name"];
                            layer.width = xImageLayer["width"];
                            layer.height = xImageLayer["height"];
                            layer.visible = xImageLayer["visible"] != undefined ? xImageLayer["visible"] : true;
                            layer.opacity = xImageLayer["opacity"] != undefined ? xImageLayer["opacity"] : 1;
                            layer.offsetX = xImageLayer["offsetx"] != undefined ? xImageLayer["offsetx"] : 0;
                            layer.offsetY = xImageLayer["offsety"] != undefined ? xImageLayer["offsety"] : 0;
                            xImage = xImageLayer["image"];
                            if (!xImage) return [3, 2];
                            _a = layer;
                            return [4, this.loadTmxImage(new es.TmxImage(), xImage, tmxDirectory)];
                        case 1:
                            _a.image = _b.sent();
                            _b.label = 2;
                        case 2:
                            layer.properties = this.parsePropertyDict(xImageLayer["properties"]);
                            return [2, layer];
                    }
                });
            });
        };
        TiledMapLoader.loadTmxLayer = function (layer, map, xLayer, width, height) {
            layer.map = map;
            layer.name = xLayer["name"];
            layer.opacity = xLayer["opacity"] != undefined ? xLayer["opacity"] : 1;
            layer.visible = xLayer["visible"] != undefined ? xLayer["visible"] : true;
            layer.offsetX = xLayer["offsetx"] != undefined ? xLayer["offsetx"] : 0;
            layer.offsetY = xLayer["offsety"] != undefined ? xLayer["offsety"] : 0;
            layer.width = xLayer["width"];
            layer.height = xLayer["height"];
            var xData = xLayer["data"];
            var encoding = xData["encoding"] != undefined ? xData["encoding"] : "csv";
            layer.tiles = new Array(width * height);
            if (encoding == "base64") {
                var br = es.TmxUtils.decode(xData.toString(), encoding, xData["compression"]);
                var index = 0;
                for (var j = 0; j < height; j++) {
                    for (var i = 0; i < width; i++) {
                        var gid = br[index];
                        layer.tiles[index++] = gid != 0 ? new es.TmxLayerTile(map, gid, i, j) : null;
                    }
                }
            }
            else if (encoding == "csv") {
                var k = 0;
                for (var _i = 0, xData_1 = xData; _i < xData_1.length; _i++) {
                    var s = xData_1[_i];
                    var gid = s;
                    var x = k % width;
                    var y = k / width;
                    layer.tiles[k++] = gid != 0 ? new es.TmxLayerTile(map, gid, x, y) : null;
                }
            }
            else if (!encoding) {
                var k = 0;
                for (var _a = 0, _b = xData["tile"]; _a < _b.length; _a++) {
                    var e = _b[_a];
                    var gid = e["gid"] != undefined ? e["gid"] : 0;
                    var x = k % width;
                    var y = k / width;
                    layer.tiles[k++] = gid != 0 ? new es.TmxLayerTile(map, gid, x, y) : null;
                }
            }
            else {
                throw new Error("TmxLayer:未知编码");
            }
            layer.properties = TiledMapLoader.parsePropertyDict(xLayer["properties"]);
            return layer;
        };
        TiledMapLoader.updateMaxTileSizes = function (tileset) {
            tileset.tiles.forEach(function (tile) {
                if (tile.image) {
                    if (tile.image.width > tileset.map.maxTileWidth)
                        tileset.map.maxTileWidth = tile.image.width;
                    if (tile.image.height > tileset.map.maxTileHeight)
                        tileset.map.maxTileHeight = tile.image.height;
                }
            });
            tileset.tileRegions.forEach(function (region) {
                var width = region.width;
                var height = region.height;
                if (width > tileset.map.maxTileWidth)
                    tileset.map.maxTileWidth = width;
                if (width > tileset.map.maxTileHeight)
                    tileset.map.maxTileHeight = height;
            });
        };
        TiledMapLoader.parseOrientationType = function (type) {
            if (type == "unknown")
                return es.OrientationType.unknown;
            if (type == "orthogonal")
                return es.OrientationType.orthogonal;
            if (type == "isometric")
                return es.OrientationType.isometric;
            if (type == "staggered")
                return es.OrientationType.staggered;
            if (type == "hexagonal")
                return es.OrientationType.hexagonal;
            return es.OrientationType.unknown;
        };
        TiledMapLoader.parseStaggerAxisType = function (type) {
            if (type == "y")
                return es.StaggerAxisType.y;
            return es.StaggerAxisType.x;
        };
        TiledMapLoader.parseStaggerIndexType = function (type) {
            if (type == "even")
                return es.StaggerIndexType.even;
            return es.StaggerIndexType.odd;
        };
        TiledMapLoader.parseRenderOrderType = function (type) {
            if (type == "right-up")
                return es.RenderOrderType.rightUp;
            if (type == "left-down")
                return es.RenderOrderType.leftDown;
            if (type == "left-up")
                return es.RenderOrderType.leftUp;
            return es.RenderOrderType.rightDown;
        };
        TiledMapLoader.parsePropertyDict = function (prop) {
            if (!prop)
                return null;
            var dict = new Map();
            for (var _i = 0, prop_1 = prop; _i < prop_1.length; _i++) {
                var p = prop_1[_i];
                var pname = p["name"];
                var valueAttr = p["value"];
                if (p["type"] == "color")
                    dict.set(pname, es.TmxUtils.color16ToUnit(valueAttr).toString());
                else
                    dict.set(pname, valueAttr);
            }
            return dict;
        };
        TiledMapLoader.parseTmxTileset = function (map, xTileset) {
            return __awaiter(this, void 0, void 0, function () {
                var xFirstGid, firstGid, source, xDocTileset;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            xFirstGid = xTileset["firstgid"];
                            firstGid = xFirstGid;
                            source = xTileset["source"];
                            if (!(source != undefined)) return [3, 2];
                            source = map.tmxDirectory + source;
                            return [4, RES.getResByUrl(source).catch(function (err) {
                                    throw new Error(err);
                                })];
                        case 1:
                            xDocTileset = _a.sent();
                            return [2, this.loadTmxTileset(new es.TmxTileset(), map, xDocTileset["tileset"], firstGid)];
                        case 2: return [2, this.loadTmxTileset(new es.TmxTileset(), map, xTileset, firstGid)];
                    }
                });
            });
        };
        TiledMapLoader.loadTmxTileset = function (tileset, map, xTileset, firstGid) {
            return __awaiter(this, void 0, void 0, function () {
                var xImage, _i, _a, e, _b, _c, _d, t, xTile, tile, id, y, column, x;
                return __generator(this, function (_e) {
                    switch (_e.label) {
                        case 0:
                            tileset.map = map;
                            tileset.firstGid = firstGid;
                            tileset.name = xTileset["name"];
                            tileset.tileWidth = xTileset["tilewidth"];
                            tileset.tileHeight = xTileset["tileheight"];
                            tileset.spacing = xTileset["spacing"] != undefined ? xTileset["spacing"] : 0;
                            tileset.margin = xTileset["margin"] != undefined ? xTileset["margin"] : 0;
                            tileset.columns = xTileset["columns"];
                            tileset.tileCount = xTileset["tilecount"];
                            tileset.tileOffset = this.parseTmxTileOffset(xTileset["tileoffset"]);
                            xImage = xTileset["image"];
                            if (!xImage) return [3, 2];
                            return [4, this.loadTmxImage(new es.TmxImage(), xTileset, map.tmxDirectory).then(function (image) {
                                    tileset.image = image;
                                }).catch(function (err) {
                                    throw new Error(err);
                                })];
                        case 1:
                            _e.sent();
                            _e.label = 2;
                        case 2:
                            tileset.terrains = [];
                            if (xTileset["terrains"])
                                for (_i = 0, _a = xTileset["terrains"]; _i < _a.length; _i++) {
                                    e = _a[_i];
                                    tileset.terrains.push(this.parseTmxTerrain(e));
                                }
                            tileset.tiles = new Map();
                            _b = [];
                            for (_c in xTileset["tiles"])
                                _b.push(_c);
                            _d = 0;
                            _e.label = 3;
                        case 3:
                            if (!(_d < _b.length)) return [3, 6];
                            t = _b[_d];
                            if (!xTileset["tiles"].hasOwnProperty(t)) return [3, 5];
                            xTile = xTileset["tiles"][t];
                            return [4, this.loadTmxTilesetTile(new es.TmxTilesetTile(), tileset, xTile, tileset.terrains, map.tmxDirectory)];
                        case 4:
                            tile = _e.sent();
                            tileset.tiles.set(tile.id == undefined ? Number(t) + 1 : tile.id, tile);
                            _e.label = 5;
                        case 5:
                            _d++;
                            return [3, 3];
                        case 6:
                            tileset.properties = this.parsePropertyDict(xTileset["properties"]);
                            tileset.tileRegions = new Map();
                            if (tileset.image) {
                                id = firstGid;
                                for (y = tileset.margin; y < tileset.image.height - tileset.margin; y += tileset.tileHeight + tileset.spacing) {
                                    column = 0;
                                    for (x = tileset.margin; x < tileset.image.width - tileset.margin; x += tileset.tileWidth + tileset.spacing) {
                                        tileset.tileRegions.set(id++, new es.Rectangle(x, y, tileset.tileWidth, tileset.tileHeight));
                                        if (++column >= tileset.columns)
                                            break;
                                    }
                                }
                            }
                            else {
                                tileset.tiles.forEach(function (tile, key) {
                                    tileset.tileRegions.set(key, new es.Rectangle(0, 0, tile.image.width, tile.image.height));
                                });
                            }
                            return [2, tileset];
                    }
                });
            });
        };
        TiledMapLoader.loadTmxTilesetTile = function (tile, tileset, xTile, terrains, tmxDirectory) {
            return __awaiter(this, void 0, void 0, function () {
                var strTerrain, index, _i, strTerrain_1, v, edge, xImage, _a, _b, _c, e, _d, _e, e;
                return __generator(this, function (_f) {
                    switch (_f.label) {
                        case 0:
                            tile.tileset = tileset;
                            tile.id = xTile["id"];
                            strTerrain = xTile["terrain"];
                            if (strTerrain) {
                                tile.terrainEdges = new Array(4);
                                index = 0;
                                for (_i = 0, strTerrain_1 = strTerrain; _i < strTerrain_1.length; _i++) {
                                    v = strTerrain_1[_i];
                                    edge = terrains[v];
                                    tile.terrainEdges[index++] = edge;
                                }
                            }
                            tile.probability = xTile["probability"] != undefined ? xTile["probability"] : 1;
                            tile.type = xTile["type"];
                            xImage = xTile["image"];
                            if (!xImage) return [3, 2];
                            _a = tile;
                            return [4, this.loadTmxImage(new es.TmxImage(), xImage, tmxDirectory)];
                        case 1:
                            _a.image = _f.sent();
                            _f.label = 2;
                        case 2:
                            tile.objectGroups = [];
                            if (xTile["objectgroup"])
                                for (_b = 0, _c = xTile["objectgroup"]; _b < _c.length; _b++) {
                                    e = _c[_b];
                                    tile.objectGroups.push(this.loadTmxObjectGroup(new es.TmxObjectGroup(), tileset.map, e));
                                }
                            tile.animationFrames = [];
                            if (xTile["animation"]) {
                                for (_d = 0, _e = xTile["animation"]["frame"]; _d < _e.length; _d++) {
                                    e = _e[_d];
                                    tile.animationFrames.push(this.loadTmxAnimationFrame(new es.TmxAnimationFrame(), e));
                                }
                            }
                            tile.properties = this.parsePropertyDict(xTile["properties"]);
                            if (tile.properties)
                                tile.processProperties();
                            return [2, tile];
                    }
                });
            });
        };
        TiledMapLoader.loadTmxAnimationFrame = function (frame, xFrame) {
            frame.gid = xFrame["tileid"];
            frame.duration = xFrame["duration"] / 1000;
            return frame;
        };
        TiledMapLoader.loadTmxObjectGroup = function (group, map, xObjectGroup) {
            group.map = map;
            group.name = xObjectGroup["name"] != undefined ? xObjectGroup["name"] : "";
            group.color = es.TmxUtils.color16ToUnit(xObjectGroup["color"]);
            group.opacity = xObjectGroup["opacity"] != undefined ? xObjectGroup["opacity"] : 1;
            group.visible = xObjectGroup["visible"] != undefined ? xObjectGroup["visible"] : true;
            group.offsetX = xObjectGroup["offsetx"] != undefined ? xObjectGroup["offsetx"] : 0;
            group.offsetY = xObjectGroup["offsety"] != undefined ? xObjectGroup["offsety"] : 0;
            var drawOrderDict = new Map();
            drawOrderDict.set("unknown", es.DrawOrderType.unkownOrder);
            drawOrderDict.set("topdown", es.DrawOrderType.IndexOrder);
            drawOrderDict.set("index", es.DrawOrderType.TopDown);
            var drawOrderValue = xObjectGroup["draworder"];
            if (drawOrderValue)
                group.drawOrder = drawOrderDict.get(drawOrderValue);
            group.objects = [];
            for (var _i = 0, _a = xObjectGroup["objects"]; _i < _a.length; _i++) {
                var e = _a[_i];
                group.objects.push(this.loadTmxObject(new es.TmxObject(), map, e));
            }
            group.properties = this.parsePropertyDict(xObjectGroup["properties"]);
            return group;
        };
        TiledMapLoader.loadTmxObject = function (obj, map, xObject) {
            obj.id = xObject["id"] != undefined ? xObject["id"] : 0;
            obj.name = xObject["name"] != undefined ? xObject["name"] : "";
            obj.x = xObject["x"];
            obj.y = xObject["y"];
            obj.width = xObject["width"] != undefined ? xObject["width"] : 0;
            obj.height = xObject["height"] != undefined ? xObject["height"] : 0;
            obj.type = xObject["type"] != undefined ? xObject["type"] : "";
            obj.visible = xObject["visible"] != undefined ? xObject["visible"] : true;
            obj.rotation = xObject["rotation"] != undefined ? xObject["rotation"] : 0;
            var xGid = xObject["gid"];
            var xEllipse = xObject["ellipse"];
            var xPolygon = xObject["polygon"];
            var xPolyline = xObject["polyline"];
            var xText = xObject["text"];
            var xPoint = xObject["point"];
            if (xGid) {
                obj.tile = new es.TmxLayerTile(map, xGid, Math.round(obj.x), Math.round(obj.y));
                obj.objectType = es.TmxObjectType.tile;
            }
            else if (xEllipse) {
                obj.objectType = es.TmxObjectType.ellipse;
            }
            else if (xPolygon) {
                obj.points = this.parsePoints(xPolygon);
                obj.objectType = es.TmxObjectType.polygon;
            }
            else if (xPolyline) {
                obj.points = this.parsePoints(xPolyline);
                obj.objectType = es.TmxObjectType.polyline;
            }
            else if (xText) {
                obj.text = this.loadTmxText(new es.TmxText(), xText);
                obj.objectType = es.TmxObjectType.text;
            }
            else if (xPoint) {
                obj.objectType = es.TmxObjectType.point;
            }
            else {
                obj.objectType = es.TmxObjectType.basic;
            }
            obj.properties = this.parsePropertyDict(xObject["properties"]);
            return obj;
        };
        TiledMapLoader.loadTmxText = function (text, xText) {
            text.fontFamily = xText["fontfamily"] != undefined ? xText["fontfamily"] : "sans-serif";
            text.pixelSize = xText["pixelsize"] != undefined ? xText["pixelsize"] : 16;
            text.wrap = xText["wrap"] != undefined ? xText["wrap"] : false;
            text.color = es.TmxUtils.color16ToUnit(xText["color"]);
            text.bold = xText["bold"] ? xText["bold"] : false;
            text.italic = xText["italic"] ? xText["italic"] : false;
            text.underline = xText["underline"] ? xText["underline"] : false;
            text.strikeout = xText["strikeout"] ? xText["strikeout"] : false;
            text.kerning = xText["kerning"] ? xText["kerning"] : true;
            text.alignment = this.loadTmxAlignment(new es.TmxAlignment(), xText);
            text.value = xText;
            return text;
        };
        TiledMapLoader.loadTmxAlignment = function (alignment, xText) {
            function firstLetterToUpperCase(str) {
                if (!str || str == "")
                    return str;
                return str[0].toString().toUpperCase() + str.substr(1);
            }
            var xHorizontal = xText["halign"] != undefined ? xText["halign"] : "left";
            alignment.horizontal = es.TmxHorizontalAlignment[firstLetterToUpperCase(xHorizontal)];
            var xVertical = xText["valign"] != undefined ? xText["valign"] : "top";
            alignment.vertical = es.TmxVerticalAlignment[firstLetterToUpperCase((xVertical))];
            return alignment;
        };
        TiledMapLoader.parsePoints = function (xPoints) {
            var points = [];
            var index = 0;
            for (var _i = 0, xPoints_1 = xPoints; _i < xPoints_1.length; _i++) {
                var s = xPoints_1[_i];
                points[index++] = this.parsePoint(s);
            }
            return points;
        };
        TiledMapLoader.parsePoint = function (pt) {
            return new es.Vector2(pt.x, pt.y);
        };
        TiledMapLoader.parseTmxTerrain = function (xTerrain) {
            var terrain = new es.TmxTerrain();
            terrain.name = xTerrain["name"];
            terrain.tile = xTerrain["tile"];
            terrain.properties = this.parsePropertyDict(xTerrain["properties"]);
            return terrain;
        };
        TiledMapLoader.parseTmxTileOffset = function (xTileOffset) {
            var tmxTileOffset = new es.TmxTileOffset();
            if (!xTileOffset) {
                tmxTileOffset.x = 0;
                tmxTileOffset.y = 0;
                return tmxTileOffset;
            }
            tmxTileOffset.x = xTileOffset["x"];
            tmxTileOffset.y = xTileOffset["y"];
            return tmxTileOffset;
        };
        TiledMapLoader.loadTmxImage = function (image, xImage, tmxDirectory) {
            return __awaiter(this, void 0, void 0, function () {
                var xSource, texture;
                return __generator(this, function (_a) {
                    switch (_a.label) {
                        case 0:
                            xSource = xImage["image"];
                            if (xSource != undefined) {
                                image.source = tmxDirectory + xSource;
                            }
                            else {
                                image.source = tmxDirectory + xImage;
                            }
                            return [4, RES.getResByUrl(image.source, null, this, RES.ResourceItem.TYPE_IMAGE).catch(function (err) {
                                    throw new Error(err);
                                })];
                        case 1:
                            texture = _a.sent();
                            image.bitmap = new egret.SpriteSheet(texture);
                            image.trans = es.TmxUtils.color16ToUnit(xImage["trans"]);
                            image.width = xImage["imagewidth"] != undefined ? xImage["imagewidth"] : texture.textureWidth;
                            image.height = xImage["imageheight"] != undefined ? xImage["imageheight"] : texture.textureHeight;
                            return [2, image];
                    }
                });
            });
        };
        return TiledMapLoader;
    }());
    es.TiledMapLoader = TiledMapLoader;
})(es || (es = {}));
var es;
(function (es) {
    var Bitmap = egret.Bitmap;
    var TiledRendering = (function () {
        function TiledRendering() {
        }
        TiledRendering.renderMap = function (map, container, position, scale, layerDepth) {
            var _this = this;
            map.layers.forEach(function (layer) {
                if (layer instanceof es.TmxLayer && layer.visible) {
                    _this.renderLayer(layer, container, position, scale, layerDepth);
                }
                else if (layer instanceof es.TmxImageLayer && layer.visible) {
                    _this.renderImageLayer(layer, container, position, scale, layerDepth);
                }
                else if (layer instanceof es.TmxGroup && layer.visible) {
                    _this.renderGroup(layer, container, position, scale, layerDepth);
                }
                else if (layer instanceof es.TmxObjectGroup && layer.visible) {
                    _this.renderObjectGroup(layer, container, position, scale, layerDepth);
                }
            });
        };
        TiledRendering.renderLayer = function (layer, container, position, scale, layerDepth) {
            if (!layer.visible)
                return;
            var tileWidth = layer.map.tileWidth * scale.x;
            var tileHeight = layer.map.tileHeight * scale.y;
            var color = es.DrawUtils.getColorMatrix(0xFFFFFF);
            for (var i = 0; i < layer.tiles.length; i++) {
                var tile = layer.tiles[i];
                if (!tile)
                    continue;
                this.renderTile(tile, container, position, scale, tileWidth, tileHeight, color, layerDepth);
            }
        };
        TiledRendering.renderLayerRenderCamera = function (layer, container, position, scale, layerDepth, camerClipBounds) {
            if (layer instanceof es.TmxLayer && layer.visible) {
                this.renderLayerCamera(layer, container, position, scale, layerDepth, camerClipBounds);
            }
            else if (layer instanceof es.TmxImageLayer && layer.visible) {
                this.renderImageLayer(layer, container, position, scale, layerDepth);
            }
            else if (layer instanceof es.TmxGroup && layer.visible) {
                this.renderGroup(layer, container, position, scale, layerDepth);
            }
            else if (layer instanceof es.TmxObjectGroup && layer.visible) {
                this.renderObjectGroup(layer, container, position, scale, layerDepth);
            }
        };
        TiledRendering.renderLayerCamera = function (layer, container, position, scale, layerDepth, camerClipBounds) {
            if (!layer.visible)
                return;
            position = position.add(layer.offset);
            camerClipBounds.location = camerClipBounds.location.subtract(position);
            var tileWidth = layer.map.tileWidth * scale.x;
            var tileHeight = layer.map.tileHeight * scale.y;
            var minX, minY, maxX, maxY = 0;
            if (layer.map.requiresLargeTileCulling) {
                minX = layer.map.worldToTilePositionX(camerClipBounds.left - (layer.map.maxTileWidth * scale.x - tileWidth));
                minY = layer.map.worldToTilePositionY(camerClipBounds.top - (layer.map.maxTileHeight * scale.y - tileHeight));
                maxX = layer.map.worldToTilePositionX(camerClipBounds.right + (layer.map.maxTileWidth * scale.x - tileWidth));
                maxY = layer.map.worldToTilePositionY(camerClipBounds.bottom + (layer.map.maxTileHeight * scale.y - tileHeight));
            }
            else {
                minX = layer.map.worldToTilePositionX(camerClipBounds.left);
                minY = layer.map.worldToTilePositionY(camerClipBounds.top);
                maxX = layer.map.worldToTilePositionX(camerClipBounds.right);
                maxY = layer.map.worldToTilePositionY(camerClipBounds.bottom);
            }
            var color = es.DrawUtils.getColorMatrix(0xFFFFFF);
            for (var y = minY; y <= maxY; y++) {
                for (var x = minX; x <= maxX; x++) {
                    var tile = layer.getTile(x, y);
                    if (tile)
                        this.renderTile(tile, container, position, scale, tileWidth, tileHeight, color, layerDepth);
                }
            }
        };
        TiledRendering.renderImageLayer = function (layer, container, position, scale, layerDepth) {
            if (!layer.visible)
                return;
            var color = es.DrawUtils.getColorMatrix(0xFFFFFF);
            var pos = es.Vector2.add(position, new es.Vector2(layer.offsetX, layer.offsetY).multiply(scale));
            if (!layer.image.texture.parent)
                container.addChild(layer.image.texture);
            layer.image.texture.x = pos.x;
            layer.image.texture.y = pos.y;
            layer.image.texture.scaleX = scale.x;
            layer.image.texture.scaleY = scale.y;
            layer.image.texture.filters = [color];
        };
        TiledRendering.renderObjectGroup = function (objGroup, container, position, scale, layerDepth) {
            if (!objGroup.visible)
                return;
            function debugRender(obj, pos) {
                if (!container)
                    return;
                if (!es.Core.debugRenderEndabled)
                    return;
                if (!obj.textField.parent && obj.name) {
                    obj.textField.text = obj.name;
                    obj.textField.size = 12;
                    obj.textField.fontFamily = "sans-serif";
                    if (obj.shape) {
                        obj.textField.x = pos.x + (obj.shape.getBounds().width - obj.textField.width) / 2 + obj.shape.getBounds().x;
                        obj.textField.y = pos.y - obj.textField.height - 5 + obj.shape.getBounds().y;
                    }
                    else {
                        obj.textField.x = pos.x + (obj.width - obj.textField.width) / 2;
                        obj.textField.y = pos.y - obj.textField.height - 5;
                    }
                    obj.textField.background = true;
                    obj.textField.backgroundColor = 0xa0a0a4;
                    obj.textField.textColor = 0xffffff;
                    container.addChild(obj.textField);
                }
            }
            for (var object in objGroup.objects) {
                var obj = objGroup.objects[object];
                if (!obj.visible)
                    continue;
                if (!es.Core.debugRenderEndabled) {
                    if (obj.objectType != es.TmxObjectType.tile && obj.objectType != es.TmxObjectType.text)
                        continue;
                }
                var pos = es.Vector2.add(position, new es.Vector2(obj.x, obj.y).multiply(scale));
                switch (obj.objectType) {
                    case es.TmxObjectType.basic:
                        if (!obj.shape.parent) {
                            obj.shape.x = obj.x;
                            obj.shape.y = obj.y;
                            container.addChild(obj.shape);
                            obj.shape.graphics.clear();
                            obj.shape.graphics.lineStyle(1, 0xa0a0a4);
                            obj.shape.graphics.beginFill(0x979798, 0.5);
                            obj.shape.graphics.drawRect(0, 0, obj.width * scale.x, obj.height * scale.y);
                            obj.shape.graphics.endFill();
                            debugRender(obj, pos);
                        }
                        break;
                    case es.TmxObjectType.point:
                        var size = objGroup.map.tileWidth * 0.5;
                        pos.x -= size * 0.5;
                        pos.y -= size * 0.5;
                        if (!obj.shape.parent) {
                            obj.shape.x = pos.x;
                            obj.shape.y = pos.y;
                            container.addChild(obj.shape);
                            obj.shape.graphics.clear();
                            obj.shape.graphics.lineStyle(1, 0xa0a0a4);
                            obj.shape.graphics.beginFill(0x979798, 0.5);
                            obj.shape.graphics.drawCircle(0, 0, 1);
                            obj.shape.graphics.endFill();
                            debugRender(obj, pos);
                        }
                        break;
                    case es.TmxObjectType.tile:
                        this.renderTilesetTile(objGroup, obj, container, pos, scale, debugRender);
                        break;
                    case es.TmxObjectType.ellipse:
                        pos = new es.Vector2(obj.x + obj.width * 0.5, obj.y + obj.height * 0.5).multiply(scale);
                        if (!obj.shape.parent) {
                            obj.shape.x = pos.x;
                            obj.shape.y = pos.y;
                            container.addChild(obj.shape);
                            obj.shape.graphics.clear();
                            obj.shape.graphics.lineStyle(1, 0xa0a0a4);
                            obj.shape.graphics.beginFill(0x979798, 0.5);
                            obj.shape.graphics.drawCircle(0, 0, obj.width * 0.5);
                            obj.shape.graphics.endFill();
                            debugRender(obj, pos);
                        }
                        break;
                    case es.TmxObjectType.polygon:
                    case es.TmxObjectType.polyline:
                        var points = [];
                        for (var i = 0; i < obj.points.length; i++)
                            points[i] = es.Vector2.multiply(obj.points[i], scale);
                        if (!obj.shape.parent && points.length > 0) {
                            obj.shape.x = pos.x;
                            obj.shape.y = pos.y;
                            container.addChild(obj.shape);
                            obj.shape.graphics.clear();
                            obj.shape.graphics.lineStyle(1, 0xa0a0a4);
                            for (var i = 0; i < points.length; i++) {
                                if (i == 0) {
                                    obj.shape.graphics.moveTo(points[i].x, points[i].y);
                                }
                                else {
                                    obj.shape.graphics.lineTo(points[i].x, points[i].y);
                                }
                            }
                            obj.shape.graphics.endFill();
                            debugRender(obj, pos);
                        }
                        break;
                    case es.TmxObjectType.text:
                        if (!obj.textField.parent) {
                            obj.textField.x = pos.x;
                            obj.textField.y = pos.y;
                            container.addChild(obj.textField);
                            obj.textField.text = obj.text.value;
                            obj.textField.textColor = obj.text.color;
                            obj.textField.bold = obj.text.bold != undefined ? obj.text.bold : false;
                            obj.textField.italic = obj.text.italic != undefined ? obj.text.italic : false;
                            obj.textField.size = obj.text.pixelSize;
                            obj.textField.fontFamily = obj.text.fontFamily;
                        }
                        break;
                    default:
                        break;
                }
            }
        };
        TiledRendering.renderTilesetTile = function (objGroup, obj, container, pos, scale, debugRender) {
            var tileset = objGroup.map.getTilesetForTileGid(obj.tile.gid);
            var sourceRect = tileset.tileRegions.get(obj.tile.gid);
            if (container) {
                if (tileset.image) {
                    if (obj.tile.horizontalFlip && obj.tile.verticalFlip) {
                        pos.x += tileset.tileHeight + (sourceRect.height * scale.y - tileset.tileHeight);
                        pos.y -= (sourceRect.width * scale.x - tileset.tileWidth);
                    }
                    else if (obj.tile.horizontalFlip) {
                        pos.x += tileset.tileWidth + (sourceRect.height * scale.y - tileset.tileHeight);
                    }
                    else if (obj.tile.verticalFlip) {
                        pos.y += (tileset.tileWidth - sourceRect.width * scale.x);
                    }
                    else {
                        pos.y += (tileset.tileHeight - sourceRect.height * scale.y);
                    }
                    var texture = tileset.image.bitmap.getTexture("" + obj.tile.gid);
                    if (!texture) {
                        texture = tileset.image.bitmap.createTexture("" + obj.tile.gid, sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height);
                    }
                    tileset.image.texture = new Bitmap(texture);
                    container.addChild(tileset.image.texture);
                    tileset.image.texture.x = pos.x;
                    tileset.image.texture.y = pos.y;
                    if (obj.tile.verticalFlip && obj.tile.horizontalFlip) {
                        tileset.image.texture.scaleX = -1;
                        tileset.image.texture.scaleY = -1;
                    }
                    else if (obj.tile.verticalFlip) {
                        tileset.image.texture.scaleX = scale.x;
                        tileset.image.texture.scaleY = -1;
                    }
                    else if (obj.tile.horizontalFlip) {
                        tileset.image.texture.scaleX = -1;
                        tileset.image.texture.scaleY = scale.y;
                    }
                    else {
                        tileset.image.texture.scaleX = scale.x;
                        tileset.image.texture.scaleY = scale.y;
                    }
                    tileset.image.texture.anchorOffsetX = 0;
                    tileset.image.texture.anchorOffsetY = 0;
                    debugRender(obj, pos);
                }
                else {
                    var tilesetTile = tileset.tiles.get(obj.tile.gid);
                    var texture = tilesetTile.image.bitmap.getTexture("" + obj.tile.gid);
                    if (!texture) {
                        texture = tilesetTile.image.bitmap.createTexture("" + obj.tile.gid, sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height);
                    }
                    pos.y -= obj.height;
                    tilesetTile.image.texture = new Bitmap(texture);
                    container.addChild(tilesetTile.image.texture);
                    tilesetTile.image.texture.width = obj.width;
                    tilesetTile.image.texture.height = obj.height;
                    tilesetTile.image.texture.x = pos.x;
                    tilesetTile.image.texture.y = pos.y;
                    if (obj.tile.verticalFlip && obj.tile.horizontalFlip) {
                        tilesetTile.image.texture.scaleX = -1;
                        tilesetTile.image.texture.scaleY = -1;
                    }
                    else if (obj.tile.verticalFlip) {
                        tilesetTile.image.texture.scaleX = scale.x;
                        tilesetTile.image.texture.scaleY = -1;
                    }
                    else if (obj.tile.horizontalFlip) {
                        tilesetTile.image.texture.scaleX = -1;
                        tilesetTile.image.texture.scaleY = scale.y;
                    }
                    else {
                        tilesetTile.image.texture.scaleX = scale.x;
                        tilesetTile.image.texture.scaleY = scale.y;
                    }
                    tilesetTile.image.texture.anchorOffsetX = 0;
                    tilesetTile.image.texture.anchorOffsetY = 0;
                }
            }
        };
        TiledRendering.renderGroup = function (group, container, position, scale, layerDepth) {
            var _this = this;
            if (!group.visible)
                return;
            group.layers.forEach(function (layer) {
                if (layer instanceof es.TmxGroup) {
                    _this.renderGroup(layer, container, position, scale, layerDepth);
                }
                if (layer instanceof es.TmxObjectGroup) {
                    _this.renderObjectGroup(layer, container, position, scale, layerDepth);
                }
                if (layer instanceof es.TmxLayer) {
                    _this.renderLayer(layer, container, position, scale, layerDepth);
                }
                if (layer instanceof es.TmxImageLayer) {
                    _this.renderImageLayer(layer, container, position, scale, layerDepth);
                }
            });
        };
        TiledRendering.renderTile = function (tile, container, position, scale, tileWidth, tileHeight, color, layerDepth) {
            var gid = tile.gid;
            var tilesetTile = tile.tilesetTile;
            if (tilesetTile && tilesetTile.animationFrames.length > 0)
                gid = tilesetTile.currentAnimationFrameGid;
            var sourceRect = tile.tileset.tileRegions.get(gid);
            var tx = Math.floor(tile.x) * tileWidth;
            var ty = Math.floor(tile.y) * tileHeight;
            var rotation = 0;
            if (tile.horizontalFlip && tile.verticalFlip) {
                tx += tileHeight + (sourceRect.height * scale.y - tileHeight);
                ty -= (sourceRect.width * scale.x - tileWidth);
            }
            else if (tile.horizontalFlip) {
                tx += tileWidth + (sourceRect.height * scale.y - tileHeight);
            }
            else if (tile.verticalFlip) {
                ty += (tileWidth - sourceRect.width * scale.x);
            }
            else {
                ty += (tileHeight - sourceRect.height * scale.y);
            }
            var pos = new es.Vector2(tx, ty).add(position);
            if (tile.tileset.image) {
                if (container) {
                    var texture = tile.tileset.image.bitmap.getTexture("" + gid);
                    if (!texture) {
                        texture = tile.tileset.image.bitmap.createTexture("" + gid, sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height);
                    }
                    tile.tileset.image.texture = new Bitmap(texture);
                    container.addChild(tile.tileset.image.texture);
                    if (tile.tileset.image.texture.x != pos.x)
                        tile.tileset.image.texture.x = pos.x;
                    if (tile.tileset.image.texture.y != pos.y)
                        tile.tileset.image.texture.y = pos.y;
                    if (tile.verticalFlip && tile.horizontalFlip) {
                        tile.tileset.image.texture.scaleX = -1;
                        tile.tileset.image.texture.scaleY = -1;
                    }
                    else if (tile.verticalFlip) {
                        tile.tileset.image.texture.scaleX = scale.x;
                        tile.tileset.image.texture.scaleY = -1;
                    }
                    else if (tile.horizontalFlip) {
                        tile.tileset.image.texture.scaleX = -1;
                        tile.tileset.image.texture.scaleY = scale.y;
                    }
                    else {
                        tile.tileset.image.texture.scaleX = scale.x;
                        tile.tileset.image.texture.scaleY = scale.y;
                    }
                    if (tile.tileset.image.texture.rotation != rotation)
                        tile.tileset.image.texture.rotation = rotation;
                    if (tile.tileset.image.texture.anchorOffsetX != 0)
                        tile.tileset.image.texture.anchorOffsetX = 0;
                    if (tile.tileset.image.texture.anchorOffsetY != 0)
                        tile.tileset.image.texture.anchorOffsetY = 0;
                }
            }
            else {
                if (tilesetTile.image.texture) {
                    if (!tilesetTile.image.bitmap.getTexture(gid.toString())) {
                        tilesetTile.image.texture = new Bitmap(tilesetTile.image.bitmap.createTexture(gid.toString(), sourceRect.x, sourceRect.y, sourceRect.width, sourceRect.height));
                        container.addChild(tilesetTile.image.texture);
                    }
                    tilesetTile.image.texture.x = pos.x;
                    tilesetTile.image.texture.y = pos.y;
                    tilesetTile.image.texture.scaleX = scale.x;
                    tilesetTile.image.texture.scaleY = scale.y;
                    tilesetTile.image.texture.rotation = rotation;
                    tilesetTile.image.texture.anchorOffsetX = 0;
                    tilesetTile.image.texture.anchorOffsetY = 0;
                    tilesetTile.image.texture.filters = [color];
                }
            }
        };
        return TiledRendering;
    }());
    es.TiledRendering = TiledRendering;
})(es || (es = {}));
var es;
(function (es) {
    var TmxTileset = (function (_super) {
        __extends(TmxTileset, _super);
        function TmxTileset() {
            return _super !== null && _super.apply(this, arguments) || this;
        }
        TmxTileset.prototype.update = function () {
            this.tiles.forEach(function (value) {
                value.updateAnimatedTiles();
            });
        };
        return TmxTileset;
    }(es.TmxDocument));
    es.TmxTileset = TmxTileset;
    var TmxTileOffset = (function () {
        function TmxTileOffset() {
        }
        return TmxTileOffset;
    }());
    es.TmxTileOffset = TmxTileOffset;
    var TmxTerrain = (function () {
        function TmxTerrain() {
        }
        return TmxTerrain;
    }());
    es.TmxTerrain = TmxTerrain;
})(es || (es = {}));
var es;
(function (es) {
    var TmxTilesetTile = (function () {
        function TmxTilesetTile() {
        }
        Object.defineProperty(TmxTilesetTile.prototype, "currentAnimationFrameGid", {
            get: function () {
                return this.animationFrames[this._animationCurrentFrame].gid + this.tileset.firstGid;
            },
            enumerable: true,
            configurable: true
        });
        TmxTilesetTile.prototype.processProperties = function () {
            var value;
            value = this.properties.get("engine.isDestructable");
            if (value)
                this.isDestructable = Boolean(value);
            value = this.properties.get("engine:isSlope");
            if (value)
                this.isSlope = Boolean(value);
            value = this.properties.get("engine:isOneWayPlatform");
            if (value)
                this.isOneWayPlatform = Boolean(value);
            value = this.properties.get("engine:slopeTopLeft");
            if (value)
                this.slopeTopLeft = Number(value);
            value = this.properties.get("engine:slopeTopRight");
            if (value)
                this.slopeTopRight = Number(value);
        };
        TmxTilesetTile.prototype.updateAnimatedTiles = function () {
            if (this.animationFrames.length == 0)
                return;
            this._animationElapsedTime += es.Time.deltaTime;
            if (this._animationElapsedTime > this.animationFrames[this._animationCurrentFrame].duration) {
                this._animationCurrentFrame = es.MathHelper.incrementWithWrap(this._animationCurrentFrame, this.animationFrames.length);
                this._animationElapsedTime = 0;
            }
        };
        return TmxTilesetTile;
    }());
    es.TmxTilesetTile = TmxTilesetTile;
    var TmxAnimationFrame = (function () {
        function TmxAnimationFrame() {
        }
        return TmxAnimationFrame;
    }());
    es.TmxAnimationFrame = TmxAnimationFrame;
})(es || (es = {}));
var es;
(function (es) {
    var TmxUtils = (function () {
        function TmxUtils() {
        }
        TmxUtils.decode = function (data, encoding, compression) {
            compression = compression || "none";
            encoding = encoding || "none";
            switch (encoding) {
                case "base64":
                    var decoded = es.Base64Utils.decodeBase64AsArray(data, 4);
                    return (compression === "none") ? decoded : es.Base64Utils.decompress(data, decoded, compression);
                case "csv":
                    return es.Base64Utils.decodeCSV(data);
                case "none":
                    var datas = [];
                    for (var i = 0; i < data.length; i++) {
                        datas[i] = +data[i].gid;
                    }
                    return datas;
                default:
                    throw new Error("未定义的编码:" + encoding);
            }
        };
        TmxUtils.color16ToUnit = function ($color) {
            if (!$color)
                return 0xFFFFFF;
            var colorStr = "0x" + $color.slice(1);
            return parseInt(colorStr, 16);
        };
        return TmxUtils;
    }());
    es.TmxUtils = TmxUtils;
})(es || (es = {}));