code:
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var CanvasTileRenderer = (function () {
      function CanvasTileRenderer(renderer) {
        this.tileAnim = [0, 0];
        this.dontUseTransform = false;
        this.renderer = renderer;
        this.tileAnim = [0, 0];
      }
      return CanvasTileRenderer;
    })();
    tilemap.CanvasTileRenderer = CanvasTileRenderer;
    PIXI.CanvasRenderer.registerPlugin("tilemap", CanvasTileRenderer);
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
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 PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var CompositeRectTileLayer = (function (_super) {
      __extends(CompositeRectTileLayer, _super);
      function CompositeRectTileLayer(zIndex, bitmaps, useSquare, texPerChild) {
        var _this = _super.call(this) || this;
        _this.shadowColor = new Float32Array([0.0, 0.0, 0.0, 0.5]);
        _this.modificationMarker = 0;
        _this._globalMat = null;
        _this._tempScale = null;
        _this.initialize.apply(_this, arguments);
        return _this;
      }
      CompositeRectTileLayer.prototype.updateTransform = function () {
        _super.prototype.displayObjectUpdateTransform.call(this);
      };
      CompositeRectTileLayer.prototype.initialize = function (
        zIndex,
        bitmaps,
        useSquare,
        texPerChild
      ) {
        this.z = this.zIndex = zIndex;
        this.useSquare = useSquare;
        this.texPerChild = texPerChild || 16;
        if (bitmaps) {
          this.setBitmaps(bitmaps);
        }
      };
      CompositeRectTileLayer.prototype.setBitmaps = function (bitmaps) {
        var texPerChild = this.texPerChild;
        var len1 = this.children.length;
        var len2 = Math.ceil(bitmaps.length / texPerChild);
        var i;
        for (i = 0; i < len1; i++) {
          this.children[i].textures = bitmaps.slice(
            i * texPerChild,
            (i + 1) * texPerChild
          );
        }
        for (i = len1; i < len2; i++) {
          this.addChild(
            new tilemap.RectTileLayer(
              this.zIndex,
              bitmaps.slice(i * texPerChild, (i + 1) * texPerChild)
            )
          );
        }
      };
      CompositeRectTileLayer.prototype.clear = function () {
        for (var i = 0; i < this.children.length; i++) this.children[i].clear();
        this.modificationMarker = 0;
      };
      CompositeRectTileLayer.prototype.addRect = function (
        num,
        u,
        v,
        x,
        y,
        tileWidth,
        tileHeight
      ) {
        if (this.children[num] && this.children[num].textures)
          this.children[num].addRect(0, u, v, x, y, tileWidth, tileHeight);
      };
      CompositeRectTileLayer.prototype.addFrame = function (
        texture_,
        x,
        y,
        animX,
        animY
      ) {
        var texture;
        var layer = null,
          ind = 0;
        var children = this.children;
        if (typeof texture_ === "number") {
          var childIndex = (texture_ / this.texPerChild) >> 0;
          layer = children[childIndex];
          if (!layer) {
            layer = children[0];
            if (!layer) {
              return false;
            }
            ind = 0;
          } else {
            ind = texture_ % this.texPerChild;
          }
          texture = layer.textures[ind];
        } else if (typeof texture_ === "string") {
          texture = PIXI.Texture.fromImage(texture_);
        } else {
          texture = texture_;
          for (var i = 0; i < children.length; i++) {
            var child = children[i];
            var tex = child.textures;
            for (var j = 0; j < tex.length; j++) {
              if (tex[j].baseTexture == texture.baseTexture) {
                layer = child;
                ind = j;
                break;
              }
            }
            if (layer) {
              break;
            }
          }
          if (!layer) {
            for (i = 0; i < children.length; i++) {
              var child = children[i];
              if (child.textures.length < this.texPerChild) {
                layer = child;
                ind = child.textures.length;
                child.textures.push(texture);
                break;
              }
            }
            if (!layer) {
              children.push(
                (layer = new tilemap.RectTileLayer(this.zIndex, texture))
              );
              ind = 0;
            }
          }
        }
        layer.addRect(
          ind,
          texture.frame.x,
          texture.frame.y,
          x,
          y,
          texture.frame.width,
          texture.frame.height,
          animX,
          animY
        );
        return true;
      };
      CompositeRectTileLayer.prototype.renderCanvas = function (renderer) {
        if (!renderer.plugins.tilemap.dontUseTransform) {
          var wt = this.worldTransform;
          renderer.context.setTransform(
            wt.a,
            wt.b,
            wt.c,
            wt.d,
            wt.tx * renderer.resolution,
            wt.ty * renderer.resolution
          );
        }
        var layers = this.children;
        for (var i = 0; i < layers.length; i++)
          layers[i].renderCanvas(renderer);
      };
      CompositeRectTileLayer.prototype.renderWebGL = function (renderer) {
        var gl = renderer.gl;
        var shader = renderer.plugins.tilemap.getShader(this.useSquare);
        renderer.setObjectRenderer(renderer.plugins.tilemap);
        renderer.bindShader(shader);
        this._globalMat = this._globalMat || new PIXI.Matrix();
        renderer._activeRenderTarget.projectionMatrix
          .copy(this._globalMat)
          .append(this.worldTransform);
        shader.uniforms.projectionMatrix = this._globalMat.toArray(true);
        shader.uniforms.shadowColor = this.shadowColor;
        if (this.useSquare) {
          var tempScale = (this._tempScale = this._tempScale || [0, 0]);
          tempScale[0] = this._globalMat.a >= 0 ? 1 : -1;
          tempScale[1] = this._globalMat.d < 0 ? 1 : -1;
          var ps = (shader.uniforms.pointScale = tempScale);
          shader.uniforms.projectionScale =
            Math.abs(this.worldTransform.a) * renderer.resolution;
        }
        var af = (shader.uniforms.animationFrame =
          renderer.plugins.tilemap.tileAnim);
        var layers = this.children;
        for (var i = 0; i < layers.length; i++)
          layers[i].renderWebGL(renderer, this.useSquare);
      };
      CompositeRectTileLayer.prototype.isModified = function (anim) {
        var layers = this.children;
        if (this.modificationMarker != layers.length) {
          return true;
        }
        for (var i = 0; i < layers.length; i++) {
          var layer = layers[i];
          if (
            layer.modificationMarker != layer.pointsBuf.length ||
            (anim && layer.hasAnim)
          ) {
            return true;
          }
        }
        return false;
      };
      CompositeRectTileLayer.prototype.clearModify = function () {
        var layers = this.children;
        this.modificationMarker = layers.length;
        for (var i = 0; i < layers.length; i++) {
          var layer = layers[i];
          layer.modificationMarker = layer.pointsBuf.length;
        }
      };
      return CompositeRectTileLayer;
    })(PIXI.Container);
    tilemap.CompositeRectTileLayer = CompositeRectTileLayer;
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var GraphicsLayer = (function (_super) {
      __extends(GraphicsLayer, _super);
      function GraphicsLayer(zIndex) {
        var _this = _super.call(this) || this;
        _this.z = _this.zIndex = zIndex;
        return _this;
      }
      GraphicsLayer.prototype.renderCanvas = function (renderer) {
        var wt = null;
        if (renderer.plugins.tilemap.dontUseTransform) {
          wt = this.transform.worldTransform;
          this.transform.worldTransform = PIXI.Matrix.IDENTITY;
        }
        renderer.plugins.graphics.render(this);
        if (renderer.plugins.tilemap.dontUseTransform) {
          this.transform.worldTransform = wt;
        }
        renderer.context.globalAlpha = 1.0;
      };
      GraphicsLayer.prototype.renderWebGL = function (renderer) {
        if (!this._webGL[renderer.CONTEXT_UID]) this.dirty = true;
        _super.prototype.renderWebGL.call(this, renderer);
      };
      GraphicsLayer.prototype.isModified = function (anim) {
        return false;
      };
      GraphicsLayer.prototype.clearModify = function () {};
      return GraphicsLayer;
    })(PIXI.Graphics);
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var RectTileLayer = (function (_super) {
      __extends(RectTileLayer, _super);
      function RectTileLayer(zIndex, texture) {
        var _this = _super.call(this) || this;
        _this.z = 0;
        _this.zIndex = 0;
        _this.pointsBuf = [];
        _this._tempSize = new Float32Array([0, 0]);
        _this._tempTexSize = 1;
        _this.modificationMarker = 0;
        _this.hasAnim = false;
        _this.vbId = 0;
        _this.vbBuffer = null;
        _this.vbArray = null;
        _this.vbInts = null;
        _this.initialize(zIndex, texture);
        return _this;
      }
      RectTileLayer.prototype.initialize = function (zIndex, textures) {
        if (!textures) {
          textures = [];
        } else if (!(textures instanceof Array) && textures.baseTexture) {
          textures = [textures];
        }
        this.textures = textures;
        this.z = this.zIndex = zIndex;
        this.visible = false;
      };
      RectTileLayer.prototype.clear = function () {
        this.pointsBuf.length = 0;
        this.modificationMarker = 0;
        this.hasAnim = false;
      };
      RectTileLayer.prototype.renderCanvas = function (renderer) {
        if (this.textures.length === 0) return;
        var points = this.pointsBuf;
        renderer.context.fillStyle = "#000000";
        for (var i = 0, n = points.length; i < n; i += 9) {
          var x1 = points[i],
            y1 = points[i + 1];
          var x2 = points[i + 2],
            y2 = points[i + 3];
          var w = points[i + 4];
          var h = points[i + 5];
          x1 += points[i + 6] * renderer.plugins.tilemap.tileAnim[0];
          y1 += points[i + 7] * renderer.plugins.tilemap.tileAnim[1];
          var textureId = points[i + 8];
          if (textureId >= 0) {
            renderer.context.drawImage(
              this.textures[textureId].baseTexture.source,
              x1,
              y1,
              w,
              h,
              x2,
              y2,
              w,
              h
            );
          } else {
            renderer.context.globalAlpha = 0.5;
            renderer.context.fillRect(x2, y2, w, h);
            renderer.context.globalAlpha = 1;
          }
        }
      };
      RectTileLayer.prototype.addRect = function (
        textureId,
        u,
        v,
        x,
        y,
        tileWidth,
        tileHeight,
        animX,
        animY
      ) {
        if (animX === void 0) {
          animX = 0;
        }
        if (animY === void 0) {
          animY = 0;
        }
        var pb = this.pointsBuf;
        this.hasAnim = this.hasAnim || animX > 0 || animY > 0;
        if (tileWidth == tileHeight) {
          pb.push(u);
          pb.push(v);
          pb.push(x);
          pb.push(y);
          pb.push(tileWidth);
          pb.push(tileHeight);
          pb.push(animX | 0);
          pb.push(animY | 0);
          pb.push(textureId);
        } else {
          var i;
          if (tileWidth % tileHeight === 0) {
            for (i = 0; i < tileWidth / tileHeight; i++) {
              pb.push(u + i * tileHeight);
              pb.push(v);
              pb.push(x + i * tileHeight);
              pb.push(y);
              pb.push(tileHeight);
              pb.push(tileHeight);
              pb.push(animX | 0);
              pb.push(animY | 0);
              pb.push(textureId);
            }
          } else if (tileHeight % tileWidth === 0) {
            for (i = 0; i < tileHeight / tileWidth; i++) {
              pb.push(u);
              pb.push(v + i * tileWidth);
              pb.push(x);
              pb.push(y + i * tileWidth);
              pb.push(tileWidth);
              pb.push(tileWidth);
              pb.push(animX | 0);
              pb.push(animY | 0);
              pb.push(textureId);
            }
          } else {
            pb.push(u);
            pb.push(v);
            pb.push(x);
            pb.push(y);
            pb.push(tileWidth);
            pb.push(tileHeight);
            pb.push(animX | 0);
            pb.push(animY | 0);
            pb.push(textureId);
          }
        }
      };
      RectTileLayer.prototype.renderWebGL = function (renderer, useSquare) {
        if (useSquare === void 0) {
          useSquare = false;
        }
        var points = this.pointsBuf;
        if (points.length === 0) return;
        var rectsCount = points.length / 9;
        var tile = renderer.plugins.tilemap;
        var gl = renderer.gl;
        if (!useSquare) {
          tile.checkIndexBuffer(rectsCount);
        }
        var shader = tile.getShader(useSquare);
        var textures = this.textures;
        if (textures.length === 0) return;
        var len = textures.length;
        if (this._tempTexSize < shader.maxTextures) {
          this._tempTexSize = shader.maxTextures;
          this._tempSize = new Float32Array(2 * shader.maxTextures);
        }
        for (var i = 0; i < len; i++) {
          if (!textures[i] || !textures[i].valid) return;
          var texture = textures[i].baseTexture;
        }
        tile.bindTextures(renderer, shader, textures);
        var vb = tile.getVb(this.vbId);
        if (!vb) {
          vb = tile.createVb(useSquare);
          this.vbId = vb.id;
          this.vbBuffer = null;
          this.modificationMarker = 0;
        }
        var vao = vb.vao;
        renderer.bindVao(vao);
        var vertexBuf = vb.vb;
        vertexBuf.bind();
        var vertices = rectsCount * shader.vertPerQuad;
        if (vertices === 0) return;
        if (this.modificationMarker != vertices) {
          this.modificationMarker = vertices;
          var vs = shader.stride * vertices;
          if (!this.vbBuffer || this.vbBuffer.byteLength < vs) {
            var bk = shader.stride;
            while (bk < vs) {
              bk *= 2;
            }
            this.vbBuffer = new ArrayBuffer(bk);
            this.vbArray = new Float32Array(this.vbBuffer);
            this.vbInts = new Uint32Array(this.vbBuffer);
            vertexBuf.upload(this.vbBuffer, 0, true);
          }
          var arr = this.vbArray,
            ints = this.vbInts;
          var sz = 0;
          var textureId, shiftU, shiftV;
          if (useSquare) {
            for (i = 0; i < points.length; i += 9) {
              textureId = points[i + 8] >> 2;
              shiftU = 1024 * (points[i + 8] & 1);
              shiftV = 1024 * ((points[i + 8] >> 1) & 1);
              arr[sz++] = points[i + 2];
              arr[sz++] = points[i + 3];
              arr[sz++] = points[i + 0] + shiftU;
              arr[sz++] = points[i + 1] + shiftV;
              arr[sz++] = points[i + 4];
              arr[sz++] = points[i + 6];
              arr[sz++] = points[i + 7];
              arr[sz++] = textureId;
            }
          } else {
            var tint = -1;
            for (i = 0; i < points.length; i += 9) {
              var eps = 0.5;
              textureId = points[i + 8] >> 2;
              shiftU = 1024 * (points[i + 8] & 1);
              shiftV = 1024 * ((points[i + 8] >> 1) & 1);
              var x = points[i + 2],
                y = points[i + 3];
              var w = points[i + 4],
                h = points[i + 5];
              var u = points[i] + shiftU,
                v = points[i + 1] + shiftV;
              var animX = points[i + 6],
                animY = points[i + 7];
              arr[sz++] = x;
              arr[sz++] = y;
              arr[sz++] = u;
              arr[sz++] = v;
              arr[sz++] = u + eps;
              arr[sz++] = v + eps;
              arr[sz++] = u + w - eps;
              arr[sz++] = v + h - eps;
              arr[sz++] = animX;
              arr[sz++] = animY;
              arr[sz++] = textureId;
              arr[sz++] = x + w;
              arr[sz++] = y;
              arr[sz++] = u + w;
              arr[sz++] = v;
              arr[sz++] = u + eps;
              arr[sz++] = v + eps;
              arr[sz++] = u + w - eps;
              arr[sz++] = v + h - eps;
              arr[sz++] = animX;
              arr[sz++] = animY;
              arr[sz++] = textureId;
              arr[sz++] = x + w;
              arr[sz++] = y + h;
              arr[sz++] = u + w;
              arr[sz++] = v + h;
              arr[sz++] = u + eps;
              arr[sz++] = v + eps;
              arr[sz++] = u + w - eps;
              arr[sz++] = v + h - eps;
              arr[sz++] = animX;
              arr[sz++] = animY;
              arr[sz++] = textureId;
              arr[sz++] = x;
              arr[sz++] = y + h;
              arr[sz++] = u;
              arr[sz++] = v + h;
              arr[sz++] = u + eps;
              arr[sz++] = v + eps;
              arr[sz++] = u + w - eps;
              arr[sz++] = v + h - eps;
              arr[sz++] = animX;
              arr[sz++] = animY;
              arr[sz++] = textureId;
            }
          }
          vertexBuf.upload(arr, 0, true);
        }
        if (useSquare) gl.drawArrays(gl.POINTS, 0, vertices);
        else
          gl.drawElements(gl.TRIANGLES, rectsCount * 6, gl.UNSIGNED_SHORT, 0);
      };
      return RectTileLayer;
    })(PIXI.Container);
    tilemap.RectTileLayer = RectTileLayer;
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var rectShaderFrag =
      "varying vec2 vTextureCoord;\nvarying vec4 vFrame;\nvarying float vTextureId;\nuniform vec4 shadowColor;\nuniform sampler2D uSamplers[%count%];\nuniform vec2 uSamplerSize[%count%];\n\nvoid main(void){\n   vec2 textureCoord = clamp(vTextureCoord, vFrame.xy, vFrame.zw);\n   float textureId = floor(vTextureId + 0.5);\n\n   vec4 color;\n   %forloop%\n   gl_FragColor = color;\n}";
    var rectShaderVert =
      "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec4 aFrame;\nattribute vec2 aAnim;\nattribute float aTextureId;\n\nuniform mat3 projectionMatrix;\nuniform vec2 animationFrame;\n\nvarying vec2 vTextureCoord;\nvarying float vTextureId;\nvarying vec4 vFrame;\n\nvoid main(void){\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n   vec2 anim = aAnim * animationFrame;\n   vTextureCoord = aTextureCoord + anim;\n   vFrame = aFrame + vec4(anim, anim);\n   vTextureId = aTextureId;\n}\n";
    var TilemapShader = (function (_super) {
      __extends(TilemapShader, _super);
      function TilemapShader(gl, maxTextures, shaderVert, shaderFrag) {
        var _this = _super.call(this, gl, shaderVert, shaderFrag) || this;
        _this.maxTextures = 0;
        _this.maxTextures = maxTextures;
        tilemap.shaderGenerator.fillSamplers(_this, _this.maxTextures);
        return _this;
      }
      return TilemapShader;
    })(PIXI.Shader);
    tilemap.TilemapShader = TilemapShader;
    var RectTileShader = (function (_super) {
      __extends(RectTileShader, _super);
      function RectTileShader(gl, maxTextures) {
        var _this =
          _super.call(
            this,
            gl,
            maxTextures,
            rectShaderVert,
            tilemap.shaderGenerator.generateFragmentSrc(
              maxTextures,
              rectShaderFrag
            )
          ) || this;
        _this.vertSize = 11;
        _this.vertPerQuad = 4;
        _this.stride = _this.vertSize * 4;
        tilemap.shaderGenerator.fillSamplers(_this, _this.maxTextures);
        return _this;
      }
      RectTileShader.prototype.createVao = function (renderer, vb) {
        var gl = renderer.gl;
        return renderer
          .createVao()
          .addIndex(this.indexBuffer)
          .addAttribute(
            vb,
            this.attributes.aVertexPosition,
            gl.FLOAT,
            false,
            this.stride,
            0
          )
          .addAttribute(
            vb,
            this.attributes.aTextureCoord,
            gl.FLOAT,
            false,
            this.stride,
            2 * 4
          )
          .addAttribute(
            vb,
            this.attributes.aFrame,
            gl.FLOAT,
            false,
            this.stride,
            4 * 4
          )
          .addAttribute(
            vb,
            this.attributes.aAnim,
            gl.FLOAT,
            false,
            this.stride,
            8 * 4
          )
          .addAttribute(
            vb,
            this.attributes.aTextureId,
            gl.FLOAT,
            false,
            this.stride,
            10 * 4
          );
      };
      return RectTileShader;
    })(TilemapShader);
    tilemap.RectTileShader = RectTileShader;
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var shaderGenerator;
    (function (shaderGenerator) {
      function fillSamplers(shader, maxTextures) {
        var sampleValues = [];
        for (var i = 0; i < maxTextures; i++) {
          sampleValues[i] = i;
        }
        shader.bind();
        shader.uniforms.uSamplers = sampleValues;
        var samplerSize = [];
        for (i = 0; i < maxTextures; i++) {
          samplerSize.push(1.0 / 2048);
          samplerSize.push(1.0 / 2048);
        }
        shader.uniforms.uSamplerSize = samplerSize;
      }
      shaderGenerator.fillSamplers = fillSamplers;
      function generateFragmentSrc(maxTextures, fragmentSrc) {
        return fragmentSrc
          .replace(/%count%/gi, maxTextures + "")
          .replace(/%forloop%/gi, this.generateSampleSrc(maxTextures));
      }
      shaderGenerator.generateFragmentSrc = generateFragmentSrc;
      function generateSampleSrc(maxTextures) {
        var src = "";
        src += "\n";
        src += "\n";
        src += "if(vTextureId <= -1.0) {";
        src += "\n\tcolor = shadowColor;";
        src += "\n}";
        for (var i = 0; i < maxTextures; i++) {
          src += "\nelse ";
          if (i < maxTextures - 1) {
            src += "if(textureId == " + i + ".0)";
          }
          src += "\n{";
          src +=
            "\n\tcolor = texture2D(uSamplers[" +
            i +
            "], textureCoord * uSamplerSize[" +
            i +
            "]);";
          src += "\n}";
        }
        src += "\n";
        src += "\n";
        return src;
      }
      shaderGenerator.generateSampleSrc = generateSampleSrc;
    })(
      (shaderGenerator =
        tilemap.shaderGenerator || (tilemap.shaderGenerator = {}))
    );
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var squareShaderVert =
      "\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\nattribute vec2 aAnim;\nattribute float aTextureId;\nattribute float aSize;\n\nuniform mat3 projectionMatrix;\nuniform vec2 samplerSize;\nuniform vec2 animationFrame;\nuniform float projectionScale;\n\nvarying vec2 vTextureCoord;\nvarying float vSize;\nvarying float vTextureId;\n\nvoid main(void){\n   gl_Position = vec4((projectionMatrix * vec3(aVertexPosition + aSize * 0.5, 1.0)).xy, 0.0, 1.0);\n   gl_PointSize = aSize * projectionScale;\n   vTextureCoord = aTextureCoord + aAnim * animationFrame;\n   vTextureId = aTextureId;\n   vSize = aSize;\n}\n";
    var squareShaderFrag =
      "\nvarying vec2 vTextureCoord;\nvarying float vSize;\nvarying float vTextureId;\n\nuniform vec4 shadowColor;\nuniform sampler2D uSamplers[%count%];\nuniform vec2 uSamplerSize[%count%];\nuniform vec2 pointScale;\n\nvoid main(void){\n   float margin = 0.5 / vSize;\n   vec2 pointCoord = (gl_PointCoord - 0.5) * pointScale + 0.5;\n   vec2 clamped = vec2(clamp(pointCoord.x, margin, 1.0 - margin), clamp(pointCoord.y, margin, 1.0 - margin));\n   vec2 textureCoord = pointCoord * vSize + vTextureCoord;\n   float textureId = vTextureId;\n   vec4 color;\n   %forloop%\n   gl_FragColor = color;\n}\n\n";
    var SquareTileShader = (function (_super) {
      __extends(SquareTileShader, _super);
      function SquareTileShader(gl, maxTextures) {
        var _this =
          _super.call(
            this,
            gl,
            maxTextures,
            squareShaderVert,
            tilemap.shaderGenerator.generateFragmentSrc(
              maxTextures,
              squareShaderFrag
            )
          ) || this;
        _this.vertSize = 8;
        _this.vertPerQuad = 1;
        _this.stride = _this.vertSize * 4;
        _this.maxTextures = maxTextures;
        tilemap.shaderGenerator.fillSamplers(_this, _this.maxTextures);
        return _this;
      }
      SquareTileShader.prototype.createVao = function (renderer, vb) {
        var gl = renderer.gl;
        return renderer
          .createVao()
          .addIndex(this.indexBuffer)
          .addAttribute(
            vb,
            this.attributes.aVertexPosition,
            gl.FLOAT,
            false,
            this.stride,
            0
          )
          .addAttribute(
            vb,
            this.attributes.aTextureCoord,
            gl.FLOAT,
            false,
            this.stride,
            2 * 4
          )
          .addAttribute(
            vb,
            this.attributes.aSize,
            gl.FLOAT,
            false,
            this.stride,
            4 * 4
          )
          .addAttribute(
            vb,
            this.attributes.aAnim,
            gl.FLOAT,
            false,
            this.stride,
            5 * 4
          )
          .addAttribute(
            vb,
            this.attributes.aTextureId,
            gl.FLOAT,
            false,
            this.stride,
            7 * 4
          );
      };
      return SquareTileShader;
    })(tilemap.TilemapShader);
    tilemap.SquareTileShader = SquareTileShader;
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap) {
    var glCore = PIXI.glCore;
    function _hackSubImage(tex, sprite, clearBuffer, clearWidth, clearHeight) {
      var gl = tex.gl;
      var baseTex = sprite.texture.baseTexture;
      if (clearBuffer && clearWidth > 0 && clearHeight > 0) {
        gl.texSubImage2D(
          gl.TEXTURE_2D,
          0,
          sprite.position.x,
          sprite.position.y,
          clearWidth,
          clearHeight,
          tex.format,
          tex.type,
          clearBuffer
        );
      }
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 1);
      gl.texSubImage2D(
        gl.TEXTURE_2D,
        0,
        sprite.position.x,
        sprite.position.y,
        tex.format,
        tex.type,
        baseTex.source
      );
    }
    var TileRenderer = (function (_super) {
      __extends(TileRenderer, _super);
      function TileRenderer(renderer) {
        var _this = _super.call(this, renderer) || this;
        _this.vbs = {};
        _this.indices = new Uint16Array(0);
        _this.lastTimeCheck = 0;
        _this.tileAnim = [0, 0];
        _this.maxTextures = 4;
        _this.texLoc = [];
        return _this;
      }
      TileRenderer.prototype.onContextChange = function () {
        var gl = this.renderer.gl;
        var maxTextures = this.maxTextures;
        this.rectShader = new tilemap.RectTileShader(gl, maxTextures);
        this.squareShader = new tilemap.SquareTileShader(gl, maxTextures);
        this.checkIndexBuffer(2000);
        this.rectShader.indexBuffer = this.indexBuffer;
        this.squareShader.indexBuffer = this.indexBuffer;
        this.vbs = {};
        this.glTextures = [];
        this.boundSprites = [];
        this.initBounds();
      };
      TileRenderer.prototype.initBounds = function () {
        var gl = this.renderer.gl;
        var tempCanvas = document.createElement("canvas");
        tempCanvas.width = 2048;
        tempCanvas.height = 2048;
        for (var i = 0; i < this.maxTextures; i++) {
          var rt = PIXI.RenderTexture.create(2048, 2048);
          rt.baseTexture.premultipliedAlpha = true;
          rt.baseTexture.scaleMode = TileRenderer.SCALE_MODE;
          rt.baseTexture.wrapMode = PIXI.WRAP_MODES.CLAMP;
          this.renderer.textureManager.updateTexture(rt);
          this.glTextures.push(rt);
          var bs = [];
          for (var j = 0; j < 4; j++) {
            var spr = new PIXI.Sprite();
            spr.position.x = 1024 * (j & 1);
            spr.position.y = 1024 * (j >> 1);
            bs.push(spr);
          }
          this.boundSprites.push(bs);
        }
      };
      TileRenderer.prototype.bindTextures = function (
        renderer,
        shader,
        textures
      ) {
        var bounds = this.boundSprites;
        var glts = this.glTextures;
        var len = textures.length;
        var maxTextures = this.maxTextures;
        if (len > 4 * maxTextures) {
          return;
        }
        var doClear = TileRenderer.DO_CLEAR;
        if (doClear && !this._clearBuffer) {
          this._clearBuffer = new Uint8Array(1024 * 1024 * 4);
        }
        var i;
        for (i = 0; i < len; i++) {
          var texture = textures[i];
          if (!texture || !textures[i].valid) continue;
          var bs = bounds[i >> 2][i & 3];
          if (!bs.texture || bs.texture.baseTexture !== texture.baseTexture) {
            bs.texture = texture;
            var glt = glts[i >> 2];
            renderer.bindTexture(glt, 0, true);
            if (doClear) {
              _hackSubImage(
                glt.baseTexture._glTextures[renderer.CONTEXT_UID],
                bs,
                this._clearBuffer,
                1024,
                1024
              );
            } else {
              _hackSubImage(
                glt.baseTexture._glTextures[renderer.CONTEXT_UID],
                bs
              );
            }
          }
        }
        this.texLoc.length = 0;
        for (i = 0; i < maxTextures; i++) {
          this.texLoc.push(renderer.bindTexture(glts[i], i, true));
        }
        shader.uniforms.uSamplers = this.texLoc;
      };
      TileRenderer.prototype.checkLeaks = function () {
        var now = Date.now();
        var old = now - 10000;
        if (this.lastTimeCheck < old || this.lastTimeCheck > now) {
          this.lastTimeCheck = now;
          var vbs = this.vbs;
          for (var key in vbs) {
            if (vbs[key].lastTimeAccess < old) {
              this.removeVb(key);
            }
          }
        }
      };
      TileRenderer.prototype.start = function () {
        this.renderer.state.setBlendMode(PIXI.BLEND_MODES.NORMAL);
      };
      TileRenderer.prototype.getVb = function (id) {
        this.checkLeaks();
        var vb = this.vbs[id];
        if (vb) {
          vb.lastAccessTime = Date.now();
          return vb;
        }
        return null;
      };
      TileRenderer.prototype.createVb = function (useSquare) {
        var id = ++TileRenderer.vbAutoincrement;
        var shader = this.getShader(useSquare);
        var gl = this.renderer.gl;
        var vb = PIXI.glCore.GLBuffer.createVertexBuffer(
          gl,
          null,
          gl.STREAM_DRAW
        );
        var stuff = {
          id: id,
          vb: vb,
          vao: shader.createVao(this.renderer, vb),
          lastTimeAccess: Date.now(),
          useSquare: useSquare,
          shader: shader,
        };
        this.vbs[id] = stuff;
        return stuff;
      };
      TileRenderer.prototype.removeVb = function (id) {
        if (this.vbs[id]) {
          this.vbs[id].vb.destroy();
          this.vbs[id].vao.destroy();
          delete this.vbs[id];
        }
      };
      TileRenderer.prototype.checkIndexBuffer = function (size) {
        var totalIndices = size * 6;
        var indices = this.indices;
        if (totalIndices <= indices.length) {
          return;
        }
        var len = indices.length || totalIndices;
        while (len < totalIndices) {
          len <<= 1;
        }
        indices = new Uint16Array(len);
        this.indices = indices;
        for (var i = 0, j = 0; i + 5 < indices.length; i += 6, j += 4) {
          indices[i + 0] = j + 0;
          indices[i + 1] = j + 1;
          indices[i + 2] = j + 2;
          indices[i + 3] = j + 0;
          indices[i + 4] = j + 2;
          indices[i + 5] = j + 3;
        }
        if (this.indexBuffer) {
          this.indexBuffer.upload(indices);
        } else {
          var gl = this.renderer.gl;
          this.indexBuffer = glCore.GLBuffer.createIndexBuffer(
            gl,
            this.indices,
            gl.STATIC_DRAW
          );
        }
      };
      TileRenderer.prototype.getShader = function (useSquare) {
        return useSquare ? this.squareShader : this.rectShader;
      };
      TileRenderer.prototype.destroy = function () {
        _super.prototype.destroy.call(this);
        this.rectShader.destroy();
        this.squareShader.destroy();
        this.rectShader = null;
        this.squareShader = null;
      };
      return TileRenderer;
    })(PIXI.ObjectRenderer);
    TileRenderer.vbAutoincrement = 0;
    TileRenderer.SCALE_MODE = PIXI.SCALE_MODES.LINEAR;
    TileRenderer.DO_CLEAR = false;
    tilemap.TileRenderer = TileRenderer;
    PIXI.WebGLRenderer.registerPlugin("tilemap", TileRenderer);
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
var PIXI;
(function (PIXI) {
  var tilemap;
  (function (tilemap_1) {
    var ZLayer = (function (_super) {
      __extends(ZLayer, _super);
      function ZLayer(tilemap, zIndex) {
        var _this = _super.call(this) || this;
        _this._lastAnimationFrame = -1;
        _this.tilemap = tilemap;
        _this.z = zIndex;
        return _this;
      }
      ZLayer.prototype.clear = function () {
        var layers = this.children;
        for (var i = 0; i < layers.length; i++) layers[i].clear();
        this._previousLayers = 0;
      };
      ZLayer.prototype.cacheIfDirty = function () {
        var tilemap = this.tilemap;
        var layers = this.children;
        var modified = this._previousLayers != layers.length;
        this._previousLayers = layers.length;
        var buf = this.canvasBuffer;
        var tempRender = this._tempRender;
        if (!buf) {
          buf = this.canvasBuffer = document.createElement("canvas");
          tempRender = this._tempRender = new PIXI.CanvasRenderer(100, 100, {
            view: buf,
          });
          tempRender.context = tempRender.rootContext;
          tempRender.plugins.tilemap.dontUseTransform = true;
        }
        if (
          buf.width != tilemap._layerWidth ||
          buf.height != tilemap._layerHeight
        ) {
          buf.width = tilemap._layerWidth;
          buf.height = tilemap._layerHeight;
          modified = true;
        }
        var i;
        if (!modified) {
          for (i = 0; i < layers.length; i++) {
            if (
              layers[i].isModified(
                this._lastAnimationFrame != tilemap.animationFrame
              )
            ) {
              modified = true;
              break;
            }
          }
        }
        this._lastAnimationFrame = tilemap.animationFrame;
        if (modified) {
          if (tilemap._hackRenderer) {
            tilemap._hackRenderer(tempRender);
          }
          tempRender.context.clearRect(0, 0, buf.width, buf.height);
          for (i = 0; i < layers.length; i++) {
            layers[i].clearModify();
            layers[i].renderCanvas(tempRender);
          }
        }
        this.layerTransform = this.worldTransform;
        for (i = 0; i < layers.length; i++) {
          this.layerTransform = layers[i].worldTransform;
          break;
        }
      };
      ZLayer.prototype.renderCanvas = function (renderer) {
        this.cacheIfDirty();
        var wt = this.layerTransform;
        renderer.context.setTransform(
          wt.a,
          wt.b,
          wt.c,
          wt.d,
          wt.tx * renderer.resolution,
          wt.ty * renderer.resolution
        );
        var tilemap = this.tilemap;
        renderer.context.drawImage(this.canvasBuffer, 0, 0);
      };
      return ZLayer;
    })(PIXI.Container);
    tilemap_1.ZLayer = ZLayer;
  })((tilemap = PIXI.tilemap || (PIXI.tilemap = {})));
})(PIXI || (PIXI = {}));
//# sourceMappingURL=pixi-tilemap.js.map


code:
//=============================================================================
// AltMenuScreen.js
//=============================================================================

/*:
 * @plugindesc Alternative menu screen layout.
 * @author Yoji Ojima
 *
 * @help This plugin does not provide plugin commands.
 */

/*:ja
 * @plugindesc メニュー画面のレイアウトを変更します。
 * @author Yoji Ojima
 *
 * @help このプラグインには、プラグインコマンドはありません。
 */

(function () {
  var _Scene_Menu_create = Scene_Menu.prototype.create;
  Scene_Menu.prototype.create = function () {
    _Scene_Menu_create.call(this);
    this._statusWindow.x = 0;
    this._statusWindow.y = this._commandWindow.height;
    this._goldWindow.x = Graphics.boxWidth - this._goldWindow.width;
  };

  Window_MenuCommand.prototype.windowWidth = function () {
    return Graphics.boxWidth;
  };

  Window_MenuCommand.prototype.maxCols = function () {
    return 4;
  };

  Window_MenuCommand.prototype.numVisibleRows = function () {
    return 2;
  };

  Window_MenuStatus.prototype.windowWidth = function () {
    return Graphics.boxWidth;
  };

  Window_MenuStatus.prototype.windowHeight = function () {
    var h1 = this.fittingHeight(1);
    var h2 = this.fittingHeight(2);
    return Graphics.boxHeight - h1 - h2;
  };

  Window_MenuStatus.prototype.maxCols = function () {
    return 4;
  };

  Window_MenuStatus.prototype.numVisibleRows = function () {
    return 1;
  };

  Window_MenuStatus.prototype.drawItemImage = function (index) {
    var actor = $gameParty.members()[index];
    var rect = this.itemRectForText(index);
    var w = Math.min(rect.width, 144);
    var h = Math.min(rect.height, 144);
    var lineHeight = this.lineHeight();
    this.changePaintOpacity(actor.isBattleMember());
    this.drawActorFace(actor, rect.x, rect.y + lineHeight * 2.5, w, h);
    this.changePaintOpacity(true);
  };

  Window_MenuStatus.prototype.drawItemStatus = function (index) {
    var actor = $gameParty.members()[index];
    var rect = this.itemRectForText(index);
    var x = rect.x;
    var y = rect.y;
    var width = rect.width;
    var bottom = y + rect.height;
    var lineHeight = this.lineHeight();
    this.drawActorName(actor, x, y + lineHeight * 0, width);
    this.drawActorLevel(actor, x, y + lineHeight * 1, width);
    this.drawActorClass(actor, x, bottom - lineHeight * 4, width);
    this.drawActorHp(actor, x, bottom - lineHeight * 3, width);
    this.drawActorMp(actor, x, bottom - lineHeight * 2, width);
    this.drawActorIcons(actor, x, bottom - lineHeight * 1, width);
  };

  var _Window_MenuActor_initialize = Window_MenuActor.prototype.initialize;
  Window_MenuActor.prototype.initialize = function () {
    _Window_MenuActor_initialize.call(this);
    this.y = this.fittingHeight(2);
  };
})();

repo_name: dazed/translations

license: unknown


code:
//=============================================================================
// AltSaveScreen.js
//=============================================================================

/*:
 * @plugindesc Alternative save/load screen layout.
 * @author Yoji Ojima
 *
 * @help This plugin does not provide plugin commands.
 */

/*:ja
 * @plugindesc セーブ／ロード画面のレイアウトを変更します。
 * @author Yoji Ojima
 *
 * @help このプラグインには、プラグインコマンドはありません。
 */

(function () {
  var _Scene_File_create = Scene_File.prototype.create;
  Scene_File.prototype.create = function () {
    _Scene_File_create.call(this);
    this._listWindow.height = this._listWindow.fittingHeight(8);
    var x = 0;
    var y = this._listWindow.y + this._listWindow.height;
    var width = Graphics.boxWidth;
    var height = Graphics.boxHeight - y;
    this._statusWindow = new Window_SavefileStatus(x, y, width, height);
    this._statusWindow.setMode(this.mode());
    this._listWindow.statusWindow = this._statusWindow;
    this._listWindow.callUpdateHelp();
    this.addWindow(this._statusWindow);
  };

  var _Scene_File_start = Scene_File.prototype.start;
  Scene_File.prototype.start = function () {
    _Scene_File_start.call(this);
    this._listWindow.ensureCursorVisible();
    this._listWindow.callUpdateHelp();
  };

  Window_SavefileList.prototype.windowWidth = function () {
    return Graphics.boxWidth;
  };

  Window_SavefileList.prototype.maxCols = function () {
    return 4;
  };

  Window_SavefileList.prototype.numVisibleRows = function () {
    return 5;
  };

  Window_SavefileList.prototype.spacing = function () {
    return 8;
  };

  Window_SavefileList.prototype.itemHeight = function () {
    return this.lineHeight() * 2;
  };

  var _Window_SavefileList_callUpdateHelp =
    Window_SavefileList.prototype.callUpdateHelp;
  Window_SavefileList.prototype.callUpdateHelp = function () {
    _Window_SavefileList_callUpdateHelp.call(this);
    if (this.active && this.statusWindow) {
      this.statusWindow.setId(this.index() + 1);
    }
  };

  function Window_SavefileStatus() {
    this.initialize.apply(this, arguments);
  }

  Window_SavefileStatus.prototype = Object.create(Window_Base.prototype);
  Window_SavefileStatus.prototype.constructor = Window_SavefileStatus;

  Window_SavefileStatus.prototype.initialize = function (x, y, width, height) {
    Window_Base.prototype.initialize.call(this, x, y, width, height);
    this._id = 1;
  };

  Window_SavefileStatus.prototype.setMode = function (mode) {
    this._mode = mode;
  };

  Window_SavefileStatus.prototype.setId = function (id) {
    this._id = id;
    this.refresh();
  };

  Window_SavefileStatus.prototype.refresh = function () {
    this.contents.clear();
    var id = this._id;
    var valid = DataManager.isThisGameFile(id);
    var info = DataManager.loadSavefileInfo(id);
    var rect = this.contents.rect;
    this.resetTextColor();
    if (this._mode === "load") {
      this.changePaintOpacity(valid);
    }
    this.drawFileId(id, rect.x, rect.y);
    if (info) {
      this.changePaintOpacity(valid);
      this.drawContents(info, rect, valid);
      this.changePaintOpacity(true);
    }
  };

  Window_SavefileStatus.prototype.drawFileId = function (id, x, y) {
    this.drawText(TextManager.file + " " + id, x, y, 180);
  };

  Window_SavefileStatus.prototype.drawContents = function (info, rect, valid) {
    var bottom = rect.y + rect.height;
    var playtimeY = bottom - this.lineHeight();
    this.drawText(info.title, rect.x + 192, rect.y, rect.width - 192);
    if (valid) {
      this.drawPartyfaces(info, rect.x, bottom - 144);
    }
    this.drawText(info.playtime, rect.x, playtimeY, rect.width, "right");
  };

  Window_SavefileStatus.prototype.drawPartyfaces = function (info, x, y) {
    if (info && info.faces) {
      for (var i = 0; i < info.faces.length; i++) {
        var data = info.faces[i];
        this.drawFace(data[0], data[1], x + i * 150, y);
      }
    }
  };
})();


code:
/*=============================================================================
 ApngPicture.js
----------------------------------------------------------------------------
 (C)2019 Triacontane
 This software is released under the MIT License.
 http://opensource.org/licenses/mit-license.php
----------------------------------------------------------------------------
 Version
 1.9.1 2022/06/06 apngのフレーム数を指定したとき停止スイッチが機能しない問題を修正
 1.9.0 2022/02/05 apngピクチャのキャッシュを手動削除する機能を追加
 1.8.4 2021/02/01 数字のみのファイルをapng指定して起動するとエラーになる問題を修正
 1.8.3 2021/01/18 1.8.2の修正でapngでないピクチャや敵キャラを表示しようとするとエラーになる問題を修正
 1.8.2 2021/01/17 キャッシュ方針を「あり」にした画像を再表示するとき、フレームを初期化するよう修正
 1.8.1 2021/01/17 キャッシュ方針を「あり」にしているとき、破棄のタイミングでエラーになる問題を修正
 1.8.0 2020/11/29 1セルごとのフレーム数をゲーム側で設定できるパラメータを追加
 1.7.2 2020/11/28 gifを使う場合はダミーのpngファイルが別途必要である旨の追記を追加
 1.7.1 2020/11/22 メニュー画面を開いたときに表示中のapngピクチャが消えないよう修正
 1.7.0 2020/11/11 APNGのアニメーションを停止、全停止できるスイッチを追加
 1.6.1 2020/11/03 プラグイン上でapng画像の高さを正しく取得できるよう修正
 1.6.0 2020/10/24 再生回数を指定したときに最初ではなく最後のフレームでアニメーションが止まる設定を追加
 1.5.0 2020/10/17 サイドビューの敵キャラをapng化できるよう修正。機能が不完全であることに変わりはありません。
 1.4.3 2020/03/17 ライブラリがpixi5.0対応によるバージョンアップで使用できなくなったのでヘルプの取得元を旧版に変更
 1.4.2 2020/03/07 キャッシュしない設定のapngを繰り返し表示、削除し続けるとメモリリークが発生する問題を修正
 1.4.1 2020/02/23 英語版のプラグインパラメータの記述が不足していたので修正
 1.4.0 2020/02/01 アニメーションのループ回数を指定できる機能を追加
 1.3.1 2019/12/31 画像を登録せずゲーム開始するとローディングが完了しない問題を修正
 1.3.0 2019/12/31 APNGのキャッシュ機能を追加
 1.2.1 2019/12/31 シーン追加画像でgifが表示されない問題を修正
 1.2.0 2019/12/31 APNGのみツクール本体の暗号化機能に対応
 1.1.0 2019/12/29 シーン追加画像の表示優先度を設定できる機能を追加
 1.0.0 2019/12/27 初版
----------------------------------------------------------------------------
 [Blog]   : https://triacontane.blogspot.jp/
 [Twitter]: https://twitter.com/triacontane/
 [GitHub] : https://github.com/triacontane/
=============================================================================*/

/*:
 * @plugindesc ApngSupportPlugin
 * @author triacontane
 *
 * @param PictureList
 * @desc List of picture images to be handled as APNG.
 * @default []
 * @type struct<PictureApngRecord>[]
 *
 * @param EnemyList
 * @desc List of enemy images to be handled as APNG.
 * @default []
 * @type struct<EnemyApngRecord>[]
 *
 * @param SideEnemyList
 * @desc List of enemy images to be handled as APNG.
 * @default []
 * @type struct<SideEnemyApngRecord>[]
 *
 * @param SceneApngList
 * @desc This is a list of APNG to be displayed for each scene.
 * @default []
 * @type struct<SceneApngRecord>[]
 *
 * @param DefaultLoopTimes
 * @desc The number of animation loops. It stops after looping the specified number of times.
 * @default 0
 * @type number
 *
 * @param AllStopSwitch
 * @desc All animations stop when the specified number switch is ON.
 * @default 0
 * @type switch
 *
 * @help ApngPicture.js
 * APNG or GIF is treated as a picture and animated on the screen.
 * From the parameters, select the file in which the APNG picture file is registered.
 * It will be animated if it is displayed in "Display Picture".
 *
 * The following libraries are required for use.
 * https://github.com/sbfkcel/pixi-apngAndGif
 *
 * Download the target file and import it from the plugin management screen.
 * https://github.com/sbfkcel/pixi-apngAndGif/blob/fd2e0fb3274bf2c360c608b42e527889d10a6330/dist/PixiApngAndGif.js
 *
 * In addition, the color tone change of the picture is not reflected.
 * Also, extensions by other plug-ins may not work.
 *
 * In addition, APNG registered from parameters can be additionally displayed for each scene.
 * Display can be controlled by switch.
 *
 * There is also a function to display APNG on the enemy character image, but this function
 * The image is incomplete because no flash is performed.
 *
 * This plugin is released under the MIT License.
 */
/*:ja
 * @plugindesc APNGピクチャプラグイン
 * @author トリアコンタン
 *
 * @param PictureList
 * @text APNGのピクチャリスト
 * @desc APNGとして扱うピクチャ画像のリストです。GIFを指定したい場合は拡張子付きで直接入力してください。
 * @default []
 * @type struct<PictureApngRecord>[]
 *
 * @param EnemyList
 * @text APNGの敵キャラリスト
 * @desc APNGとして扱う敵キャラ画像のリストです。GIFを指定したい場合は拡張子付きで直接入力してください。この機能は不完全です。
 * @default []
 * @type struct<EnemyApngRecord>[]
 *
 * @param SideEnemyList
 * @text APNGのSV敵キャラリスト
 * @desc APNGとして扱うSV敵キャラ画像のリストです。サイドビューの画像を使用したい場合はこちらから登録してください。
 * @default []
 * @type struct<SideEnemyApngRecord>[]
 *
 * @param SceneApngList
 * @text シーンAPNGのリスト
 * @desc シーンごとに表示するAPNGのリストです。GIFを指定したい場合は拡張子付きで直接入力してください。
 * @default []
 * @type struct<SceneApngRecord>[]
 *
 * @param DefaultLoopTimes
 * @text デフォルトループ回数
 * @desc アニメーションのループ回数です。指定した回数分ループ再生すると止まります。0を指定すると無限にアニメーションします。
 * @default 0
 * @type number
 *
 * @param StopLastFrame
 * @text 最終フレームで止める
 * @desc ループ回数が決まっているアニメーションを再生したとき最初のフレームではなく最後のフレームでアニメーションが止まります。
 * @default false
 * @type boolean
 *
 * @param AllStopSwitch
 * @text 全停止スイッチ
 * @desc 指定した番号スイッチがONのとき全てのアニメーションが停止します。
 * @default 0
 * @type switch
 *
 * @param FrameCount
 * @text 1セルのフレーム数
 * @desc 設定すると1セルごとのフレーム数をゲーム側で固定にできます。
 * @default 0
 * @type number
 *
 * @help ApngPicture.js
 * APNG、もしくはGIFアニメをピクチャとして画面上にアニメ表示します。
 * パラメータからAPNGのピクチャとして登録したファイルを
 * 「ピクチャの表示」で表示すればアニメーションされます。
 *
 * 使用には以下のライブラリが必要です。
 * https://github.com/sbfkcel/pixi-apngAndGif
 *
 * ただし、ライブラリの最新版はpixi5.0に対応した結果、ツクールMV側の最新である4.0では
 * 再生できなくなりました。よって最新版ではなく、下記の旧版を使用する必要があります。
 *
 * 対象ファイルをダウンロードしてプラグイン管理画面から取り込んでください。
 * https://github.com/sbfkcel/pixi-apngAndGif/blob/fd2e0fb3274bf2c360c608b42e527889d10a6330/dist/PixiApngAndGif.js
 *
 * なお、ピクチャの色調変更は反映されません。
 * また、他のプラグインによる拡張が機能しない場合があります。
 *
 * APNGをキャッシュすることで表示時の硬直を抑えることができますが、
 * キャッシュする量に比例して初回起動時に時間が掛かるようになります。
 * また、キャッシュした画像は1画面中で同時に2つ以上は表示できません。
 * 使用する場合はご注意ください。
 *
 * さらに、各シーンでパラメータから登録したAPNGを追加表示できます。
 * スイッチによる表示制御が可能です。
 *
 * 敵キャラ画像にAPNGを表示する機能もありますが、この機能は
 * 画像のフラッシュが一切行われないため不完全です。
 * また、画像サイズの大きいAPNGを読み込むと、表示が遅くなる場合があります。
 * 表示が遅い場合はGIFアニメもお試しください。
 *
 * GIFを使用したい場合、拡張子がgifのファイルはツクールMVで認識されないので
 * パラメータに拡張子付きのファイル名を直接入力してください。
 * 同一ファイル名のpngファイルが別途必要です。(中身は空の画像でOK)
 * また、GIFはツクールMVの暗号化機能の対象外となります。
 *
 * ピクチャのAPNGのみスクリプトからキャッシュの手動削除ができます。
 * SceneManager.destroyApngCache('拡張子無しファイル名');
 *
 * ファイル名を指定しない場合、キャッシュの全削除となります。
 * SceneManager.destroyApngCache();
 *
 * このプラグインにはプラグインコマンドはありません。
 *
 * 利用規約：
 *  作者に無断で改変、再配布が可能で、利用形態（商用、18禁利用等）
 *  についても制限はありません。
 *  このプラグインはもうあなたのものです。
 */

/*~struct~SceneApngRecord:ja
 *
 * @param SceneName
 * @text 対象シーン
 * @desc 画像を追加するシーンです。
 * @type select
 * @default Scene_Title
 * @option タイトル
 * @value Scene_Title
 * @option ゲームオーバー
 * @value Scene_Gameover
 * @option バトル
 * @value Scene_Battle
 * @option メインメニュー
 * @value Scene_Menu
 * @option アイテム
 * @value Scene_Item
 * @option スキル
 * @value Scene_Skill
 * @option 装備
 * @value Scene_Equip
 * @option ステータス
 * @value Scene_Status
 * @option オプション
 * @value Scene_Options
 * @option セーブ
 * @value Scene_Save
 * @option ロード
 * @value Scene_Load
 * @option ゲーム終了
 * @value Scene_End
 * @option ショップ
 * @value Scene_Shop
 * @option 名前入力
 * @value Scene_Name
 * @option デバッグ
 * @value Scene_Debug
 * @option サウンドテスト
 * @value Scene_SoundTest
 * @option 用語辞典
 * @value Scene_Glossary
 *
 * @param FileName
 * @text ファイル名
 * @desc 追加するAPNGのファイル名です。
 * @default
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param CachePolicy
 * @text キャッシュ方針
 * @desc 画像のキャッシュ方針です。大量にキャッシュするとメモリ使用量に影響が出る場合があります。
 * @default 0
 * @type select
 * @option キャッシュしない
 * @value 0
 * @option 初回表示時にキャッシュ
 * @value 1
 * @option ゲーム起動時にキャッシュ
 * @value 2
 *
 * @param X
 * @text X座標
 * @desc 追加するAPNGのX座標です。
 * @default 0
 * @type number
 *
 * @param Y
 * @text Y座標
 * @desc 追加するAPNGのY座標です。
 * @default 0
 * @type number
 *
 * @param Origin
 * @text 原点
 * @desc 追加するAPNGの原点です。
 * @default 0
 * @type select
 * @option 左上
 * @value 0
 * @option 中央
 * @value 1
 *
 * @param Priority
 * @text 優先度
 * @desc 画像の表示優先度です。最背面は画面上に表示されないことが多いので通常の使用では推奨しません。
 * @default 0
 * @type select
 * @option 最前面
 * @value 0
 * @option ウィンドウの下
 * @value 1
 * @option 最背面
 * @value 2
 *
 * @param Switch
 * @text 出現条件スイッチ
 * @desc 指定したスイッチがONのときのみ表示されます。指定しない場合、常に表示されます。
 * @default 0
 * @type switch
 *
 * @param LoopTimes
 * @text ループ回数
 * @desc アニメーションのループ回数です。0を指定するとデフォルト設定に従います。
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @text 停止スイッチ
 * @desc 指定した番号スイッチがONのときアニメーションが停止します。
 * @default 0
 * @type switch
 */

/*~struct~PictureApngRecord:ja
 *
 * @param FileName
 * @text ファイル名
 * @desc 追加するAPNGのファイル名です。
 * @default
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param CachePolicy
 * @text キャッシュ方針
 * @desc 画像のキャッシュ方針です。大量にキャッシュするとメモリ使用量に影響が出る場合があります。
 * @default 0
 * @type select
 * @option キャッシュしない
 * @value 0
 * @option 初回表示時にキャッシュ
 * @value 1
 * @option ゲーム起動時にキャッシュ
 * @value 2
 *
 * @param LoopTimes
 * @text ループ回数
 * @desc アニメーションのループ回数です。0を指定するとデフォルト設定に従います。
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @text 停止スイッチ
 * @desc 指定した番号スイッチがONのときアニメーションが停止します。
 * @default 0
 * @type switch
 */

/*~struct~EnemyApngRecord:ja
 *
 * @param FileName
 * @text ファイル名
 * @desc 追加するAPNGのファイル名です。
 * @default
 * @require 1
 * @dir img/enemies/
 * @type file
 *
 * @param CachePolicy
 * @text キャッシュ方針
 * @desc 画像のキャッシュ方針です。大量にキャッシュするとメモリ使用量に影響が出る場合があります。
 * @default 0
 * @type select
 * @option キャッシュしない
 * @value 0
 * @option 初回表示時にキャッシュ
 * @value 1
 * @option ゲーム起動時にキャッシュ
 * @value 2
 *
 * @param LoopTimes
 * @text ループ回数
 * @desc アニメーションのループ回数です。0を指定するとデフォルト設定に従います。
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @text 停止スイッチ
 * @desc 指定した番号スイッチがONのときアニメーションが停止します。
 * @default 0
 * @type switch
 */

/*~struct~SideEnemyApngRecord:ja
 *
 * @param FileName
 * @text ファイル名
 * @desc 追加するAPNGのファイル名です。
 * @default
 * @require 1
 * @dir img/sv_enemies/
 * @type file
 *
 * @param CachePolicy
 * @text キャッシュ方針
 * @desc 画像のキャッシュ方針です。大量にキャッシュするとメモリ使用量に影響が出る場合があります。
 * @default 0
 * @type select
 * @option キャッシュしない
 * @value 0
 * @option 初回表示時にキャッシュ
 * @value 1
 * @option ゲーム起動時にキャッシュ
 * @value 2
 *
 * @param LoopTimes
 * @text ループ回数
 * @desc アニメーションのループ回数です。0を指定するとデフォルト設定に従います。
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @text 停止スイッチ
 * @desc 指定した番号スイッチがONのときアニメーションが停止します。
 * @default 0
 * @type switch
 */

/*~struct~SceneApngRecord:
 *
 * @param SceneName
 * @desc Target Scene
 * @type select
 * @default Scene_Title
 * @option Scene_Title
 * @option Scene_Gameover
 * @option Scene_Battle
 * @option Scene_Menu
 * @option Scene_Item
 * @option Scene_Skill
 * @option Scene_Equip
 * @option Scene_Status
 * @option Scene_Options
 * @option Scene_Save
 * @option Scene_Load
 * @option Scene_End
 * @option Scene_Shop
 * @option Scene_Name
 * @option Scene_Debug
 * @option Scene_SoundTest
 * @option Scene_Glossary
 *
 * @param FileName
 * @desc File name of apng
 * @default
 * @require 1
 * @dir img/system/
 * @type file
 *
 * @param CachePolicy
 * @desc Cache policy
 * @default 0
 * @type select
 * @option None
 * @value 0
 * @option Cache on first display
 * @value 1
 * @option Cache at game start
 * @value 2
 *
 * @param X
 * @desc X of apng
 * @default 0
 * @type number
 *
 * @param Y
 * @desc Y of apng
 * @default 0
 * @type number
 *
 * @param Origin
 * @desc Origin of apng
 * @default 0
 * @type select
 * @option Upper left
 * @value 0
 * @option Center
 * @value 1
 *
 * @param Priority
 * @desc Priority of apng
 * @default 0
 * @type select
 * @option Front
 * @value 0
 * @option Under window
 * @value 1
 * @option Back
 * @value 2
 *
 * @param Switch
 * @desc Displayed only when the specified switch is ON
 * @default 0
 * @type switch
 *
 * @param LoopTimes
 * @desc The number of animation loops. Specifying 0 follows the default setting.
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @desc The animation stops when the specified number switch is turned on.
 * @default 0
 * @type switch
 */

/*~struct~PictureApngRecord:
 *
 * @param FileName
 * @desc File name of apng
 * @default
 * @require 1
 * @dir img/pictures/
 * @type file
 *
 * @param CachePolicy
 * @desc Cache policy
 * @default 0
 * @type select
 * @option None
 * @value 0
 * @option Cache on first display
 * @value 1
 * @option Cache at game start
 * @value 2
 *
 * @param LoopTimes
 * @desc The number of animation loops. Specifying 0 follows the default setting.
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @desc The animation stops when the specified number switch is turned on.
 * @default 0
 * @type switch
 */

/*~struct~EnemyApngRecord:
 *
 * @param FileName
 * @desc File name of apng
 * @default
 * @require 1
 * @dir img/enemies/
 * @type file
 *
 * @param CachePolicy
 * @desc Cache policy
 * @default 0
 * @type select
 * @option None
 * @value 0
 * @option Cache on first display
 * @value 1
 * @option Cache at game start
 * @value 2
 *
 * @param LoopTimes
 * @desc The number of animation loops. Specifying 0 follows the default setting.
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @desc The animation stops when the specified number switch is turned on.
 * @default 0
 * @type switch
 */

/*~struct~SideEnemyApngRecord:
 *
 * @param FileName
 * @desc File name of apng
 * @default
 * @require 1
 * @dir img/sv_enemies/
 * @type file
 *
 * @param CachePolicy
 * @desc Cache policy
 * @default 0
 * @type select
 * @option None
 * @value 0
 * @option Cache on first display
 * @value 1
 * @option Cache at game start
 * @value 2
 *
 * @param LoopTimes
 * @desc The number of animation loops. Specifying 0 follows the default setting.
 * @default 0
 * @type number
 *
 * @param StopSwitch
 * @desc The animation stops when the specified number switch is turned on.
 * @default 0
 * @type switch
 */

(function () {
  "use strict";

  var getClassName = function (object) {
    return object.constructor
      .toString()
      .replace(/function\s+(.*)\s*\([\s\S]*/m, "$1");
  };

  /**
   * Create plugin parameter. param[paramName] ex. param.commandPrefix
   * @param script currentScript
   * @returns {Object} Created parameter
   */
  var createPluginParameter = function (script) {
    var pluginName = script.src.replace(/^.*\/(.*).js$/, function () {
      return arguments[1];
    });
    var paramReplacer = function (key, value) {
      if (value === "null") {
        return value;
      }
      if (value[0] === '"' && value[value.length - 1] === '"') {
        return value;
      }
      try {
        return JSON.parse(value);
      } catch (e) {
        return value;
      }
    };
    var parameter = JSON.parse(
      JSON.stringify(PluginManager.parameters(pluginName), paramReplacer)
    );
    PluginManager.setParameters(pluginName, parameter);
    return parameter;
  };

  var param = createPluginParameter(document.currentScript);

  /**
   * ApngLoader
   * APNGもしくはGIF画像を読み込んで保持します。
   */
  class ApngLoader {
    constructor(folder, paramList) {
      this._folder = folder;
      this._fileHash = {};
      this._cachePolicy = {};
      this._options = {};
      this._paramList = paramList;
      if (this._paramList && this._paramList.length > 0) {
        this.addAllImage();
      }
      this._spriteCache = {};
    }

    addAllImage() {
      var option = this.getLoadOption();
      this._paramList.forEach(function (item) {
        this.addImage(item, option);
      }, this);
      PIXI.loader.onComplete.add(this.cacheStartup.bind(this));
      ApngLoader.startLoading();
    }

    addImage(item, option) {
      var name = String(item.FileName) || "";
      var ext = Decrypter.hasEncryptedImages ? "rpgmvp" : "png";
      name = name.replace(/\.gif$/gi, function () {
        ext = "gif";
        return "";
      });
      var path = name.match(/http:/)
        ? name
        : `img/${this._folder}/${name}.${ext}`;
      if (!this._fileHash.hasOwnProperty(name)) {
        this._fileHash[name] = ApngLoader.convertDecryptExt(path);
        this._cachePolicy[name] = item.CachePolicy;
        this._options[name] = item;
        PIXI.loader.add(path, option);
      }
    }

    getLoadOption() {
      return {
        loadType: PIXI.loaders.Resource.LOAD_TYPE.XHR,
        xhrType: PIXI.loaders.Resource.XHR_RESPONSE_TYPE.BUFFER,
        crossOrigin: "",
      };
    }

    createSprite(name) {
      if (!this.isApng(name)) {
        return null;
      }
      if (this._isNeedCache(name)) {
        if (this._spriteCache[name]) {
          return this._spriteCache[name];
        }
        var sprite = this._createPixiApngAndGif(name);
        this._spriteCache[name] = sprite;
        return sprite;
      } else {
        return this._createPixiApngAndGif(name);
      }
    }

    destroyAllCache() {
      Object.keys(this._spriteCache).forEach(function (key) {
        this.destroyCache(key);
      }, this);
    }

    destroyCache(name) {
      var sprite = this._spriteCache[name];
      if (!sprite) {
        return;
      }
      ApngLoader.destroyApng(sprite);
      delete this._spriteCache[name];
    }

    _createPixiApngAndGif(name) {
      var pixiApng = new PixiApngAndGif(
        this._fileHash[name],
        ApngLoader._resource
      );
      var loopCount = this._options[name].LoopTimes || param.DefaultLoopTimes;
      if (loopCount > 0) {
        pixiApng.play(loopCount);
      }
      var sprite = pixiApng.sprite;
      sprite.pixiApng = pixiApng;
      sprite.pixiApngOption = this._options[name];
      return sprite;
    }

    _isNeedCache(name) {
      return this._cachePolicy[name] > 0;
    }

    isApng(name) {
      return !!this._fileHash[name];
    }

    cacheStartup() {
      Object.keys(this._cachePolicy).forEach(function (name) {
        if (this._cachePolicy[name] === 2) {
          this.createSprite(name);
        }
      }, this);
    }

    static startLoading() {
      this._loading = true;
    }

    static onLoadResource(progress, resource) {
      this._resource = resource;
      Object.keys(this._resource).forEach(function (key) {
        if (this._resource[key].extension === "rpgmvp") {
          ApngLoader.decryptResource(key);
        }
      }, this);
    }

    static decryptResource(key) {
      var resource = this._resource[key];
      resource.data = Decrypter.decryptArrayBuffer(resource.data);
      var newKey = ApngLoader.convertDecryptExt(key);
      resource.name = newKey;
      resource.url = newKey;
      resource.extension = "png";
      this._resource[newKey] = resource;
      delete this._resource[key];
    }

    static isReady() {
      return !!this._resource || !this._loading;
    }

    static convertDecryptExt(key) {
      return key.replace(/\.rpgmvp$/, ".png");
    }

    static destroyApng(sprite) {
      var pixiApng = sprite.pixiApng;
      if (pixiApng) {
        pixiApng.textures.forEach(function (texture) {
          texture.baseTexture.destroy();
          texture.destroy();
        });
        pixiApng.stop();
      }
      sprite.pixiApng = null;
    }
  }
  ApngLoader._resource = null;

  var _Scene_Boot_isReady = Scene_Boot.prototype.isReady;
  Scene_Boot.prototype.isReady = function () {
    var result = _Scene_Boot_isReady.apply(this, arguments);
    if (result) {
      SceneManager.setupApngLoaderIfNeed();
    }
    return result && ApngLoader.isReady();
  };

  var _Scene_Base_create = Scene_Base.prototype.create;
  Scene_Base.prototype.create = function () {
    _Scene_Base_create.apply(this, arguments);
    this.createSceneApng();
  };

  Scene_Base.prototype.createSceneApng = function () {
    this._apngList = this.findSceneApngList().map(function (item) {
      return new SpriteSceneApng(item);
    }, this);
  };

  var _Scene_Base_terminate = Scene_Base.prototype.terminate;
  Scene_Base.prototype.terminate = function () {
    _Scene_Base_terminate.apply(this, arguments);
    this.destroySceneApng();
    if (this._spriteset) {
      this._spriteset.destroyApngPicture();
    }
  };

  Scene_Base.prototype.destroySceneApng = function () {
    this._apngList.forEach(function (sprite) {
      sprite.destroyApngIfNeed();
    });
  };

  var _Scene_Base_start = Scene_Base.prototype.start;
  Scene_Base.prototype.start = function () {
    _Scene_Base_start.apply(this, arguments);
    this.setApngPriority();
  };

  Scene_Base.prototype.setApngPriority = function () {
    var windowLayerIndex = this._windowLayer
      ? this.getChildIndex(this._windowLayer)
      : 0;
    this._apngList.forEach(function (sprite) {
      switch (sprite.getPriority()) {
        case 0:
          this.addChild(sprite);
          break;
        case 1:
          this.addChildAt(sprite, windowLayerIndex);
          windowLayerIndex++;
          break;
        default:
          this.addChildAt(sprite, 0);
      }
    }, this);
  };

  Scene_Base.prototype.findSceneApngList = function () {
    var currentSceneName = getClassName(this);
    return (param.SceneApngList || []).filter(function (data) {
      return data.SceneName === currentSceneName;
    }, this);
  };

  Spriteset_Base.prototype.destroyApngPicture = function () {
    this.destroyApngPictureContainer(this._pictureContainer);
    // for PicturePriorityCustomize.js
    this.destroyApngPictureContainer(this._pictureContainerLower);
    this.destroyApngPictureContainer(this._pictureContainerMiddle);
    this.destroyApngPictureContainer(this._pictureContainerUpper);
  };

  Spriteset_Base.prototype.destroyApngPictureContainer = function (container) {
    if (!container) {
      return;
    }
    container.children.forEach(function (sprite) {
      if (sprite.destroyApngIfNeed) {
        sprite.destroyApngIfNeed();
      }
    });
  };

  Spriteset_Base.prototype.removeDestroyedApngPicture = function () {
    this.removeDestroyedApngPictureContainer(this._pictureContainer);
    // for PicturePriorityCustomize.js
    this.removeDestroyedApngPictureContainer(this._pictureContainerLower);
    this.removeDestroyedApngPictureContainer(this._pictureContainerMiddle);
    this.removeDestroyedApngPictureContainer(this._pictureContainerUpper);
  };

  Spriteset_Base.prototype.removeDestroyedApngPictureContainer = function (
    container
  ) {
    if (!container) {
      return;
    }
    container.children.forEach(function (sprite) {
      if (sprite.removeDestroyedApng) {
        sprite.removeDestroyedApng();
      }
    });
  };

  Spriteset_Battle.prototype.destroyApngPicture = function () {
    Spriteset_Base.prototype.destroyApngPicture.call(this);
    this._enemySprites.forEach(function (sprite) {
      sprite.destroyApngIfNeed();
    });
  };

  /**
   * SceneManager
   * APNGのローダを管理します。
   */
  SceneManager.setupApngLoaderIfNeed = function () {
    if (this._apngLoaderPicture) {
      return;
    }
    PIXI.loader.onComplete.add(ApngLoader.onLoadResource.bind(ApngLoader));
    this._apngLoaderPicture = new ApngLoader("pictures", param.PictureList);
    this._apngLoaderEnemy = new ApngLoader("enemies", param.EnemyList);
    this._apngLoaderSideEnemy = new ApngLoader(
      "sv_enemies",
      param.SideEnemyList
    );
    this._apngLoaderSystem = new ApngLoader("system", param.SceneApngList);
    PIXI.loader.load();
  };

  SceneManager.destroyApngCache = function (name) {
    if (name) {
      this._apngLoaderPicture.destroyCache(name);
    } else {
      this._apngLoaderPicture.destroyAllCache();
    }
    if (this._scene._spriteset) {
      this._scene._spriteset.removeDestroyedApngPicture();
    }
  };

  SceneManager.tryLoadApngPicture = function (name) {
    return this._apngLoaderPicture.createSprite(name);
  };

  SceneManager.tryLoadApngEnemy = function (name) {
    return this._apngLoaderEnemy.createSprite(name);
  };

  SceneManager.tryLoadApngSideEnemy = function (name) {
    return this._apngLoaderSideEnemy.createSprite(name);
  };

  SceneManager.tryLoadApngSystem = function (name) {
    return this._apngLoaderSystem.createSprite(name);
  };

  /**
   * Sprite
   * APNGの読み込み処理を追加します。
   */
  Sprite.prototype.addApngChild = function (name) {
    this.destroyApngIfNeed();
    this._apngSprite = this.loadApngSprite(name);
    if (this._apngSprite) {
      if (this.isApngCache()) {
        this._apngSprite.pixiApng.jumpToFrame(0);
        this._apngSprite.pixiApng.play();
      }
      this.addChild(this._apngSprite);
      const original = ImageManager.loadPicture(name);
      original.addLoadListener(
        function () {
          this.bitmap = new Bitmap(original.width, original.height);
        }.bind(this)
      );
      this.updateApngAnchor();
      this.updateApngBlendMode();
    }
    this._apngLoopCount = 1;
    this._apngLoopFrame = 0;
  };

  Sprite.prototype.destroyApngIfNeed = function () {
    if (this._apngSprite) {
      if (!this.isApngCache()) {
        this.destroyApng();
      } else {
        this.removeApng();
      }
    }
  };

  Sprite.prototype.destroyApng = function () {
    ApngLoader.destroyApng(this._apngSprite);
    this.removeApng();
  };

  Sprite.prototype.removeApng = function () {
    this.removeChild(this._apngSprite);
    this._apngSprite = null;
  };

  Sprite.prototype.removeDestroyedApng = function () {
    if (this._apngSprite && !this._apngSprite.pixiApng) {
      this.removeApng();
    }
  };

  Sprite.prototype.isApngCache = function () {
    return this._apngSprite.pixiApngOption.CachePolicy !== 0;
  };

  Sprite.prototype.loadApngSprite = function () {
    return null;
  };

  Sprite.prototype.updateApngAnchor = function () {
    if (this._apngSprite) {
      this._apngSprite.anchor.x = this.anchor.x;
      this._apngSprite.anchor.y = this.anchor.y;
    }
  };

  Sprite.prototype.updateApngBlendMode = function () {
    if (this._apngSprite) {
      this._apngSprite.blendMode = this.blendMode;
    }
  };

  var _Sprite_update = Sprite.prototype.update;
  Sprite.prototype.update = function () {
    _Sprite_update.apply(this, arguments);
    if (this._apngSprite) {
      if (param.FrameCount > 0 && !this._apngSpritePause) {
        this.updateApngFrame();
      }
      this.updateApngSwitchStop();
      this.updateApngFrameStop();
    }
  };

  Sprite.prototype.updateApngFrame = function () {
    var frameLength = this._apngSprite.pixiApng.getFramesLength();
    var frame =
      Math.floor(Graphics.frameCount / param.FrameCount) % frameLength;
    this._apngSprite.pixiApng.jumpToFrame(frame);
  };

  Sprite.prototype.updateApngFrameStop = function () {
    if (!param.StopLastFrame) {
      return;
    }
    var frame = this._apngSprite.pixiApng.__status.frame;
    if (frame < this._apngLoopFrame) {
      this._apngLoopCount++;
    }
    this._apngLoopFrame = frame;
    var loopLimit = this.getLoopTimes();
    if (loopLimit <= 0) {
      return;
    }
    var frameLength = this._apngSprite.pixiApng.getFramesLength();
    if (loopLimit <= this._apngLoopCount && frameLength <= frame + 1) {
      this._apngSprite.pixiApng.stop();
    }
  };

  Sprite.prototype.updateApngSwitchStop = function () {
    if (
      $gameSwitches.value(this.getStopSwitch()) ||
      $gameSwitches.value(param.AllStopSwitch)
    ) {
      this._apngSprite.pixiApng.stop();
      this._apngSpritePause = true;
    } else if (this._apngSpritePause) {
      this._apngSprite.pixiApng.play();
      this._apngSpritePause = false;
    }
  };

  Sprite.prototype.getLoopTimes = function () {
    return this._apngSprite.pixiApngOption.LoopTimes || param.DefaultLoopTimes;
  };

  Sprite.prototype.getStopSwitch = function () {
    return this._apngSprite.pixiApngOption.StopSwitch;
  };

  /**
   * Sprite_Picture
   * APNGとして登録されているピクチャの読み込みを追加します。
   */
  var _Sprite_Picture_loadBitmap = Sprite_Picture.prototype.loadBitmap;
  Sprite_Picture.prototype.loadBitmap = function () {
    _Sprite_Picture_loadBitmap.apply(this, arguments);
    this.addApngChild(this._pictureName);
  };

  Sprite_Picture.prototype.loadApngSprite = function (name) {
    return SceneManager.tryLoadApngPicture(name);
  };

  var _Sprite_Picture_updateOrigin = Sprite_Picture.prototype.updateOrigin;
  Sprite_Picture.prototype.updateOrigin = function () {
    _Sprite_Picture_updateOrigin.apply(this, arguments);
    this.updateApngAnchor();
  };

  var _Sprite_Picture_updateOther = Sprite_Picture.prototype.updateOther;
  Sprite_Picture.prototype.updateOther = function () {
    _Sprite_Picture_updateOther.apply(this, arguments);
    this.updateApngBlendMode();
  };

  var _Sprite_Picture_updateBitmap = Sprite_Picture.prototype.updateBitmap;
  Sprite_Picture.prototype.updateBitmap = function () {
    _Sprite_Picture_updateBitmap.apply(this, arguments);
    var picture = this.picture();
    if (!picture && this._apngSprite) {
      this.destroyApngIfNeed();
    }
  };

  Sprite_Picture.prototype.removeDestroyedApng = function () {
    Sprite.prototype.removeDestroyedApng.apply(this, arguments);
    var picture = this.picture();
    if (picture) {
      $gameScreen.erasePictureByInstance(picture);
    }
  };

  Game_Screen.prototype.erasePictureByInstance = function (targetPicture) {
    var index = this._pictures.findIndex(function (picture) {
      return picture === targetPicture;
    });
    if (index >= 0) {
      this._pictures[index] = null;
    }
  };

  /**
   * Sprite_Enemy
   * APNGとして登録されている敵キャラの読み込みを追加します。
   */
  var _Sprite_Enemy_loadBitmap = Sprite_Enemy.prototype.loadBitmap;
  Sprite_Enemy.prototype.loadBitmap = function (name, hue) {
    _Sprite_Enemy_loadBitmap.apply(this, arguments);
    this.addApngChild(name);
  };

  Sprite_Enemy.prototype.loadApngSprite = function (name) {
    if ($gameSystem.isSideView()) {
      return SceneManager.tryLoadApngSideEnemy(name);
    } else {
      return SceneManager.tryLoadApngEnemy(name);
    }
  };

  /**
   * SpriteSceneApng
   * シーンに追加表示するAPNGスプライトです。
   */
  class SpriteSceneApng extends Sprite {
    constructor(item) {
      super();
      this.setup(item);
    }

    setup(item) {
      this.addApngChild(item.FileName);
      this.x = item.X;
      this.y = item.Y;
      if (item.Origin === 1) {
        this.anchor.x = 0.5;
        this.anchor.y = 0.5;
      }
      this._switch = item.Switch;
      this._priority = item.Priority;
    }

    loadApngSprite(name) {
      return SceneManager.tryLoadApngSystem(name.replace(/\..*/, ""));
    }

    update() {
      super.update();
      this.visible = this.isValid();
    }

    isValid() {
      return !this._switch || $gameSwitches.value(this._switch);
    }

    getPriority() {
      return this._priority;
    }
  }
})();