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:
//=============================================================================
// InputForm.js
// PUBLIC DOMAIN
// ----------------------------------------------------------------------------
// 2017/09/03 iOSで「決定」ボタンを押せないバグを修正＆裏のゲーム画面のクリックを無効に
// 2018/12/06 入力欄の大きさを画面サイズに追従＆iPhoneで画面がズレるバグ修正＆文字サイズ設定＆初期値設定
// 2020/08/22 RPGツクールMZに対応
//=============================================================================

/*:
 * @target MZ
 * @plugindesc フォーム作って文字入力（修正版）
 * @author １１１, くらむぼん
 *
 *
 * @help
 * 文字入力フォームを表示して、文字を入力させます。
 * イベントコマンドの「名前入力の処理」とは違い、
 * 慣れ親しんだキーボード入力やフリック入力などを用いられます。
 * また、漢字を含む自由な文字が入力できます。
 *
 * ---準備---
 * ゲームフォルダにあるcssフォルダ（なければ作る）に111_InputForm.cssを入れましょう。
 * ちなみにこのファイルをいじって入力フォームのデザイン・幅などを変えられます。
 * いじり方がわからなかったら「css 書き方」などで検索だ！
 *
 * ---RPGツクールMZでの使い方---
 * プラグインコマンドを用いて、入力欄を表示できます。
 * 最低限「入力欄のX位置」「入力欄のY位置」で表示位置を調整して、
 * 「入力結果の代入先」に変数を設定すれば動きます。
 * 必要なら他のパラメータも調節してみてください。
 *
 * ---RPGツクールMVでの使い方---
 * ◆プラグインコマンド：InputForm x=350;y=200;v=11;max=5;
 * みたいな感じで。この例だとx350,y200の位置に表示、結果を11番の変数に保存。
 * 最大文字数は5（maxは省略すれば無制限にもできる）
 *
 * 時間切れなどを作りたい時は、if_s=3;を付けると
 * ”スイッチ３がONになった場合”に強制終了できます
 * 並列イベントの中で、スイッチ３をONにするイベントを作りましょう
 * （ハマリポイント１）なおこの際、強制終了した瞬間の
 * テキストが結果の変数にしっかり保存されていることに注意。
 *
 * 入力が終わるまで次のイベントコマンドは読み込みません
 * （ハマリポイント２）次のイベントコマンドの読み込みまでは
 * 少し間があるため結果の変数を他の並列処理で上書きしないよう注意。
 *
 *
 * 機能追加：
 * Inputform （中略）btn_x=100;btn_y=100;
 * という書き方で、「決定」ボタンの位置を細かく調整できるようにしました。
 * 値はテキストボックスからの相対位置で、デフォルトはbtn_x=0;btn_y=50;です。
 *
 * （2018/12/06追加）
 * 入力欄や決定ボタンの縮尺が画面の縮尺に合わせて伸び縮みするようになりました。
 *
 * Inputform （中略）font_size=30;
 * で入力欄・決定ボタンの文字の大きさを変更できます。
 * font_sizeを指定しなければfont_size=24になります。
 *
 * Inputform （中略）placeholder=文章;
 * で「文章」の内容を最初から入力欄に表示しておくことができます。
 * デフォルトネームを設定しておく場合などにご利用ください。
 * なお、placeholder=$;と指定すると変数vに入っている内容が表示されます。
 *
 * ライセンス：
 * このプラグインの利用法に制限はありません。お好きなようにどうぞ。
 *
 * @command show
 * @text 文字入力の処理
 * @desc
 *
 * @arg target_x
 * @type number
 * @text 入力欄のX位置
 *
 * @arg target_y
 * @type number
 * @text 入力欄のY位置
 *
 * @arg variables_id
 * @type variable
 * @text 入力結果の代入先
 *
 * @arg max_count
 * @type number
 * @text 最大文字数
 *
 * @arg if_switch_id
 * @type switch
 * @text ONのとき入力を強制終了
 *
 * @arg button_x
 * @type number
 * @min -10000
 * @default 0
 * @text 決定ボタンの相対X位置
 *
 * @arg button_y
 * @type number
 * @min -10000
 * @default 50
 * @text 決定ボタンの相対Y位置
 *
 * @arg unit_font_size
 * @type number
 * @default 24
 * @text 文字サイズ
 *
 * @arg placeholder
 * @type string
 * @text 入力欄の初期値
 */
(function () {
  function stopPropagation(event) {
    event.stopPropagation();
  }

  // css追加
  (function () {
    var css = document.createElement("link");
    css.rel = "stylesheet";
    css.type = "text/css";
    css.href = "./css/111_InputForm.css";
    var b_top = document.getElementsByTagName("head")[0];
    b_top.appendChild(css);
  })();
  // キー入力不可にする為に
  Input.form_mode = false;
  var _Input_onKeyDown = Input._onKeyDown;
  Input._onKeyDown = function (event) {
    if (Input.form_mode) return;
    _Input_onKeyDown.call(this, event);
  };
  var _Input_onKeyUp = Input._onKeyUp;
  Input._onKeyUp = function (event) {
    if (Input.form_mode) return;
    _Input_onKeyUp.call(this, event);
  };
  // 入力終わるまで次のイベントコマンド読み込まない
  var _Game_Interpreter_updateWaitMode =
    Game_Interpreter.prototype.updateWaitMode;
  Game_Interpreter.prototype.updateWaitMode = function () {
    if (this._waitMode == "input_form") return true;
    return _Game_Interpreter_updateWaitMode.call(this);
  };

  HTMLElement.prototype.postionAdjust = function (
    screen_postion,
    target_postion,
    unitFontSize
  ) {
    this.style.left =
      screen_postion[0] + target_postion[0] * Graphics._realScale + "px";
    this.style.top =
      screen_postion[1] + target_postion[1] * Graphics._realScale + "px";
    this.style.fontSize = unitFontSize * Graphics._realScale + "px";
    this.style.maxWidth = "calc(100% - " + this.style.left + ")";
    this.style.maxHeight = "calc(100% - " + this.style.top + ")";
  };
  // 引数のx=350;y=200;みたいなのを可能にする
  var argHash = function (text, arg_names) {
    var _args = new Array(arg_names.length);
    var ary = text.split(";");
    ary.forEach(function (str) {
      var s_ary = str.split("=");
      var prop = s_ary[0].toLowerCase();
      var value = s_ary[1];
      _args[arg_names.indexOf(prop)] = value;
    });
    return _args;
  };
  //=============================================================================
  // Game_Interpreter - register plugin commands
  //=============================================================================
  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === "InputForm") {
      var _ary = argHash(args[0], [
        "x",
        "y",
        "v",
        "max",
        "if_s",
        "btn_x",
        "btn_y",
        "font_size",
        "placeholder",
      ]);
      var target_x = +_ary[0];
      var target_y = +_ary[1];
      var variables_id = +_ary[2];
      var max_count = _ary[3] || null;
      var if_switch_id = Number(_ary[4]) || null;
      var button_x = +_ary[5] || 0;
      var button_y = _ary[6] === "" || isNaN(_ary[6]) ? 50 : +_ary[6];
      var unit_font_size = _ary[7] === "" || isNaN(_ary[7]) ? 24 : +_ary[7];
      var placeholder = _ary[8];
      this._inputForm(
        target_x,
        target_y,
        variables_id,
        max_count,
        if_switch_id,
        button_x,
        button_y,
        unit_font_size,
        placeholder
      );
    }
  };

  if (PluginManager.registerCommand) {
    PluginManager.registerCommand("111_InputForm", "show", function (args) {
      var {
        target_x,
        target_y,
        variables_id,
        max_count,
        if_switch_id,
        button_x,
        button_y,
        unit_font_size,
        placeholder,
      } = args;
      this._inputForm(
        +target_x,
        +target_y,
        +variables_id,
        +max_count,
        +if_switch_id,
        +button_x,
        +button_y,
        +unit_font_size,
        placeholder
      );
    });
  }

  Game_Interpreter.prototype._inputForm = function (
    target_x,
    target_y,
    variables_id,
    max_count,
    if_switch_id,
    button_x,
    button_y,
    unit_font_size,
    placeholder
  ) {
    var interpreter = this;
    var gui = {
      input: null,
      submit: null,
      is_pc: true,
      init: function () {
        this.is_pc = Utils.isNwjs();
        this.create();
        this.input.focus();
        this.screenAdjust();
      },
      create: function () {
        // 入力フォーム
        this.input = document.createElement("input");
        this.input.setAttribute("id", "_111_input");
        if (max_count) this.input.setAttribute("maxlength", max_count);

        if (placeholder === "$") {
          placeholder = $gameVariables.value(variables_id);
        }
        this.input.setAttribute("value", placeholder || "");
        document.body.appendChild(this.input);
        // 送信ボタン
        this.submit = document.createElement("input");
        this.submit.setAttribute("type", "submit");
        this.submit.setAttribute("id", "_111_submit");
        this.submit.setAttribute("value", "Submit");
        document.body.appendChild(this.submit);
      },
      success: function () {
        $gameVariables.setValue(variables_id, this.input.value);
        this.end();
      },
      cancel: function () {
        $gameVariables.setValue(variables_id, this.input.value);
        this.end();
      },
      start: function () {
        interpreter.setWaitMode("input_form");
        Input.clear();
        Input.form_mode = true;
        // SceneManager._scene.stop();
      },
      end: function () {
        this.input.remove(); // document.body.removeChild(this.input);
        this.submit.remove();
        window.removeEventListener("resize", resizeEvent, false);
        interpreter.setWaitMode("");
        Input.form_mode = false;
        clearInterval(_event);
        // SceneManager._scene.start();
      },
      screenAdjust: function () {
        // canvasの左上を基準にした位置に合わせる
        var screen_x, screen_y;
        var _canvas =
          document.getElementById("UpperCanvas") ||
          document.getElementById("gameCanvas");
        var rect = _canvas.getBoundingClientRect();
        screen_x = rect.left;
        screen_y = rect.top;
        this.input.postionAdjust(
          [screen_x, screen_y],
          [target_x, target_y],
          unit_font_size
        );
        this.submit.postionAdjust(
          [screen_x, screen_y],
          [target_x + button_x, target_y + button_y],
          unit_font_size
        );
      },
    };
    //
    gui.init();
    // 送信するイベントgui.input.onkeydown = function(e){
    gui.input.addEventListener("keydown", function (e) {
      if (e.keyCode === 13) {
        // 決定キーで送信
        Input.clear();
        gui.success();
        // 親へのイベント伝播を止める（documentのkeydownが反応しないように）
        e.stopPropagation();
      }
    });
    gui.input.addEventListener("mousedown", stopPropagation); // 裏のゲーム画面のクリック暴発を防ぐ
    gui.input.addEventListener("touchstart", stopPropagation); // iOSでclickイベント取れない対策
    gui.submit.addEventListener("mousedown", stopPropagation); // 裏のゲーム画面のクリック暴発を防ぐ
    gui.submit.addEventListener("touchstart", stopPropagation); // iOSでclickイベント取れない対策
    gui.submit.addEventListener("click", function () {
      // 送信ボタンクリック
      gui.success();
      return false;
    });
    // キャンセルするイベント
    if (if_switch_id) {
      var _event = setInterval(function () {
        if ($gameSwitches.value(if_switch_id)) {
          // clearInterval(_event);
          gui.cancel();
        }
      }, 1);
    }

    // webではウィンドー大きさ変わる度に%求め直すイベントもいる
    //if(! gui.is_pc){
    var resizeEvent = gui.screenAdjust.bind(gui);
    window.addEventListener("resize", resizeEvent, false);
    //}
    //
    gui.start();
  };
})();

repo_name: dazed/translations

license: unknown


code:
/*:
 * @plugindesc ウィンドウの幅とX位置を調整する
 * @author 鈴原マキナ (Altered)
 *
 * @param windowWidth
 * @text ウィンドウ幅
 * @type number
 * @default 816
 * @parent dataType
 *
 * * @param positionX
 * @text ウィンドウX位置
 * @type number
 * @default 0
 * @parent dataType
 */

(function () {
  "use strict";
  const parameters = PluginManager.parameters("ALT_BoxWidth");
  const param = JSON.parse(
    JSON.stringify(parameters, function (key, value) {
      try {
        return JSON.parse(value);
      } catch (e) {
        try {
          return eval(value);
        } catch (e) {
          return value;
        }
      }
    })
  );

  Window_Message.prototype.initialize = function () {
    const width = this.windowWidth();
    const height = this.windowHeight();
    const x = param.positionX;
    Window_Base.prototype.initialize.call(this, x, 0, width, height);
    this.openness = 0;
    this.initMembers();
    this.createSubWindows();
    this.updatePlacement();
  };

  Window_Message.prototype.windowWidth = function () {
    return param.windowWidth;
  };
})();


code:
//=============================================================================
// ALT_HideGameEndMenuCommand.js
//=============================================================================
/*:ja
 * @plugindesc メニューコマンドから『ゲーム終了』コマンドを削除する。
 * @author 鈴原マキナ（Altered）
 *
 * @help このプラグインに、プラグインコマンドはありません。
 *
 * バージョン情報
 * 2021/05/12　1.0.0　初版
 *
 */

(function () {
  "use strict";

  Scene_Menu.prototype.createCommandWindow = function () {
    this._commandWindow = new Window_MenuCommand(0, 0);
    this._commandWindow.setHandler("item", this.commandItem.bind(this));
    this._commandWindow.setHandler("skill", this.commandPersonal.bind(this));
    this._commandWindow.setHandler("equip", this.commandPersonal.bind(this));
    this._commandWindow.setHandler("status", this.commandPersonal.bind(this));
    this._commandWindow.setHandler(
      "formation",
      this.commandFormation.bind(this)
    );
    this._commandWindow.setHandler("options", this.commandOptions.bind(this));
    this._commandWindow.setHandler("save", this.commandSave.bind(this));
    // this._commandWindow.setHandler('gameEnd',   this.commandGameEnd.bind(this));
    this._commandWindow.setHandler("cancel", this.popScene.bind(this));
    this.addWindow(this._commandWindow);
  };

  Window_MenuCommand.prototype.makeCommandList = function () {
    this.addMainCommands();
    this.addFormationCommand();
    this.addOriginalCommands();
    this.addOptionsCommand();
    this.addSaveCommand();
    // this.addGameEndCommand();
  };
})();


code:
//=============================================================================
// ALT_ItemDisableSwitch.js
// by Altered (Machina Suzuhara)
// Version: 1.00
//=============================================================================

/*:ja
 * @plugindesc  ■■■Altered■■■ スイッチONでアイテム使用不可
 * @author 鈴原マキナ（Altered）
 *
 * @help
 * 使用不可のアイテムを不透明で選択不可にする。
 * アイテムのメモ欄に<disableSwitch:スイッチ番号>を記入すると、
 * そのスイッチがONになると使用不可になる。
 *
 *
 * ---------------------------------------------------------
 * 【利用規約】
 * 『ALT_ItemDisableSwitch.js』(以下、本プラグイン)の利用にあたり、
 * いかなる理由であっても、以下の項目を遵守すること。
 *
 * -本プラグインの著作権は『鈴原マキナ（Altered） 』（以下、著作権者）が有する。
 * -著作権者の許可無く、本プラグインを素材としての配布、公開を禁止する。
 * -著作権者の許可無く、ゲーム等のアプリケーションへ組み込む形式での配布、公開を禁止する。
 * -著作権者の許可無く、画像や動画等、著作権が認められる範囲での本プラグインのソースコードの公開を禁止する。
 * -本プラグインの利用する場合は、必ず著作権者の許可を文面で得ること。
 * -録音または録画された『口頭や身振りでの著作権者の許可』を得ていても、必ず文面でも利用許可を得ること。
 *
 * 以上、六項目を利用規約とする。
 * ---------------------------------------------------------
 *
 *
 * バージョン情報
 * 2022/08/15　1.0.0　初版
 *
 *
 */

(function () {
  "use strict";

  Window_ItemList.prototype.isCurrentItemEnabled = function () {
    let disableSwitch;
    if (this.item() && this.item().meta) {
      const meta = this.item().meta;
      disableSwitch = meta.disableSwitch
        ? $gameSwitches.value(Number(meta.disableSwitch))
        : false;
    }
    return !disableSwitch && this.isEnabled(this.item());
  };

  Window_ItemList.prototype.isEnabled = function (item) {
    if (!item || !item.meta) return $gameParty.canUse(item);
    const meta = item.meta;
    const disableSwitch = meta.disableSwitch
      ? $gameSwitches.value(Number(meta.disableSwitch))
      : false;
    return !disableSwitch && $gameParty.canUse(item);
  };
})();


code:
//=============================================================================
// ALT_MakeEmptyMap_BugFix.js
//=============================================================================
/*:ja
 * @plugindesc 倍速しながら戦闘からマップに戻る際の処理に保険を掛ける。
 * @author 鈴原マキナ（Altered）
 *
 * @help このプラグインに、プラグインコマンドはありません。
 *
 * バージョン情報
 * 2022/09/22　1.0.0　初版
 *
 */

(function () {
  "use strict";

  Game_Map.prototype.isLoopHorizontal = function () {
    if (!!!$dataMap) {
      DataManager.makeEmptyMap();
    }
    return $dataMap.scrollType === 2 || $dataMap.scrollType === 3;
  };
})();


code:
//=============================================================================
// ALT_MessageOutline.js
// by Altered (Machina)
// Version: 2.00
//=============================================================================

/*:
 * @plugindesc 「文章の表示」の文字のアウトラインを変更
 *
 * @author Altered (Machina)
 * @help 「文章の表示(Window_Message)」と同じ処理で描画される文字のアウトライン等を変更します。
 *
 *--------------------------------------------------
 *
 * 1.利用上の注意
 * ・有償、無償、年齢制限コンテンツでの利用に、特に制限はありません。
 *
 * ・利用に関しては全て自己責任で行ってください。
 *   本スクリプトを使用すること及びゲームなどを制作・配布・販売することにより、
 *   第三者との間で生じたトラブル等に関しては、本素材作成者は一切責任を負わないものとします。
 *
 * ・素材制作者に許可無く改変可。改変物の配布時には、
 *   添付ドキュメント内に本素材を使用して制作した旨を表記してください。
 *
 * 2.利用報告
 * ・特に必要ありません。
 *
 * 3.禁止事項
 * ・素材単体での二次配布。
 * ・素材への直リンク。
 *
 *  4.サポート
 * ・競合などの対処は致しかねますので、予めご了承下さい。
 *
 *
 * @param アウトラインの太さ
 * @default 4
 * @desc 標準は"4"です。なしにする場合は"0"。
 *
 * @param アウトラインの色(赤)
 * @default 0
 * @desc 0～255。初期値は「0」
 *
 * @param アウトラインの色(緑)
 * @default 0
 * @desc 0～255。初期値は「0」
 *
 * @param アウトラインの色(青)
 * @default 0
 * @desc 0～255。初期値は「0」
 *
 * @param アウトラインの透過率
 * @default 0.5
 * @desc 標準は"0.5"です。最大値はは"1"。
 *
 * @param フォントサイズ
 * @default 28
 * @desc フォントサイズを指定します。おまけなのでSupportなしです。
 *
 *
 */

//=============================================================================

(function () {
  var parameters = PluginManager.parameters("ALT_MessageOutline");
  var paramFontSize = Number(parameters["フォントサイズ"] || "28");
  var paramOutlineSize = Number(parameters["アウトラインの太さ"] || "4");
  var paramOutlineRed = Number(parameters["アウトラインの色(赤)"] || "0");
  var paramOutlineGreen = Number(parameters["アウトラインの色(緑)"] || "0");
  var paramOutlineBlue = Number(parameters["アウトラインの色(青)"] || "0");
  var paramOutlineAlpha = Number(parameters["アウトラインの透過率"] || "0.5");

  var _Window_Message_resetFontSettings =
    Window_Message.prototype.resetFontSettings;
  Window_Message.prototype.resetFontSettings = function () {
    _Window_Message_resetFontSettings.call(this);
    this.contents.fontSize = paramFontSize;
    this.contents.outlineWidth = paramOutlineSize;
    this.contents.outlineColor =
      "rgba(" +
      paramOutlineRed +
      "," +
      paramOutlineGreen +
      "," +
      paramOutlineBlue +
      "," +
      paramOutlineAlpha +
      ")";
  };

  var _Window_ChoiceList_resetFontSettings =
    Window_ChoiceList.prototype.resetFontSettings;
  Window_ChoiceList.prototype.resetFontSettings = function () {
    _Window_ChoiceList_resetFontSettings.call(this);
    this.contents.fontSize = paramFontSize;
    this.contents.outlineWidth = paramOutlineSize;
    this.contents.outlineColor =
      "rgba(" +
      paramOutlineRed +
      "," +
      paramOutlineGreen +
      "," +
      paramOutlineBlue +
      "," +
      paramOutlineAlpha +
      ")";
  };
})();


code:
/*:
 * @plugindesc メッセージウィンドウの幅とX位置とフォントサイズを調整する
 * @author 鈴原マキナ (Altered)
 *
 * @help
 * フォントサイズをデフォルトから小さくすると、制御文字でアイコンを表示した際に
 * アイコンの下辺とテキストの下辺が自動で同じ位置に調整されます。
 *
 * @param windowWidth
 * @text ウィンドウ幅
 * @type number
 * @default 816
 * @parent dataType
 *
 * @param positionX
 * @text ウィンドウX位置
 * @type number
 * @default 0
 * @parent dataType
 *
 * @param fontSize
 * @text テキストのフォントサイズ
 * @desc デフォルトフォントサイズ = 28
 * @type number
 * @default 28
 * @parent dataType
 */

(function () {
  "use strict";
  const parameters = PluginManager.parameters("ALT_OptionalMessageWindow");

  const param = JSON.parse(
    JSON.stringify(parameters, function (key, value) {
      try {
        return JSON.parse(value);
      } catch (e) {
        try {
          return eval(value);
        } catch (e) {
          return value;
        }
      }
    })
  );

  Window_Message.prototype.initialize = function () {
    const width = this.windowWidth();
    const height = this.windowHeight();
    const x = param.positionX;
    Window_Base.prototype.initialize.call(this, x, 0, width, height);
    this.openness = 0;
    this.initMembers();
    this.createSubWindows();
    this.updatePlacement();
  };

  Window_Message.prototype.windowWidth = function () {
    return param.windowWidth;
  };

  Window_Message.prototype.resetFontSettings = function () {
    this.contents.fontFace = this.standardFontFace();
    this.contents.fontSize = param.fontSize;
    this.resetTextColor();
  };

  Window_Message.prototype.processNormalCharacter = function (textState) {
    const c = textState.text[textState.index++];
    const w = this.textWidth(c);
    // const standardFontSize = 26;
    // let adjustY            = standardFontSize - param.fontSize;
    this.contents.drawText(
      c,
      textState.x + 3,
      textState.y + 3,
      w * 2,
      textState.height
    );
    textState.x += w + 0;
  };

  Window_ChoiceList.prototype.resetFontSettings = function () {
    this.contents.fontFace = this.standardFontFace();
    this.contents.fontSize = param.fontSize;
    this.resetTextColor();
  };

  Window_ChoiceList.prototype.processNormalCharacter = function (textState) {
    const c = textState.text[textState.index++];
    const w = this.textWidth(c);
    // const standardFontSize = 26;
    // let adjustY            = standardFontSize - param.fontSize;
    this.contents.drawText(
      c,
      textState.x + 3,
      textState.y + 3,
      w * 2,
      textState.height
    );
    textState.x += w + 0;
  };
})();


code:
//=============================================================================
// ALT_ShopStatus.js
// by Altered (Machina Suzuhara)
// Version: 1.00
//=============================================================================

/*:
 * @plugindesc ■■■Altered■■■ ショップステータスに表示されるメンバーをスイッチで管理
 * @author Altered (Machina Suzuhara)
 *
 * @help
 * 【利用規約】
 * いかなる理由においても、"ALT_ShopStatus.js(以下、本プラグイン)"を
 * 本プラグイン制作者『Altered (Machina Suzuhara)』の許可なく、
 * 本プラグインの『配布』や『公開』、『販売』、『ゲーム等のアプリケーションへ
 * 組み込む形式での配布及び公開及び使用』を禁止する。
 */

(function () {
  "use strict";

  Window_ShopStatus.prototype.statusMembers = function () {
    const members = [];
    members.push($gameActors.actor(1));
    if ($gameSwitches.value(578)) members.push($gameActors.actor(2));
    if ($gameSwitches.value(579)) members.push($gameActors.actor(3));
    if ($gameSwitches.value(580)) members.push($gameActors.actor(4));
    return members;
  };
})();


code:
//=============================================================================
// ALT_StandingPictureMove.js
// by Altered (Machina Suzuhara)
// Version: 1.01
//=============================================================================

/*:
 * @plugindesc パラメータに"立ち絵"として予め設定したピクチャを、プラグインコマンドで動かします。立ち絵は16枚まで登録可能。
 * @author Altered (Machina Suzuhara)
 *
 * @param default_position_y
 * @desc 立ち絵を表示する際、この値の分だけ位置（高さ）が調整されます
 * この値は、このプラグインで表示する全ての立ち絵に適用されます
 * @default 0
 *
 * @param Stand_1_PictureNumber
 * @desc "立ち絵01"のピクチャ番号を指定
 *
 * @param Stand_1_CharacterName
 * @desc "立ち絵01"のキャラ名を設定
 *
 * @param Stand_1_FileName
 * @desc プラグインコマンドで"立ち絵01"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_2_PictureNumber
 * @desc "立ち絵02"のピクチャ番号を指定
 *
 * @param Stand_2_CharacterName
 * @desc "立ち絵02"のキャラ名を設定
 *
 * @param Stand_2_FileName
 * @desc プラグインコマンドで"立ち絵02"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_3_PictureNumber
 * @desc "立ち絵03"のピクチャ番号を指定
 *
 * @param Stand_3_CharacterName
 * @desc "立ち絵03"のキャラ名を設定
 *
 * @param Stand_3_FileName
 * @desc プラグインコマンドで"立ち絵03"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_4_PictureNumber
 * @desc "立ち絵04"のピクチャ番号を指定
 *
 * @param Stand_4_CharacterName
 * @desc "立ち絵04"のキャラ名を設定
 *
 * @param Stand_4_FileName
 * @desc プラグインコマンドで"立ち絵04"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_5_PictureNumber
 * @desc "立ち絵05"のピクチャ番号を指定
 *
 * @param Stand_5_CharacterName
 * @desc "立ち絵05"のキャラ名を設定
 *
 * @param Stand_5_FileName
 * @desc プラグインコマンドで"立ち絵05"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_6_PictureNumber
 * @desc "立ち絵06"のピクチャ番号を指定
 *
 * @param Stand_6_CharacterName
 * @desc "立ち絵06"のキャラ名を設定
 *
 * @param Stand_6_FileName
 * @desc プラグインコマンドで"立ち絵06"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_7_PictureNumber
 * @desc "立ち絵07"のピクチャ番号を指定
 *
 * @param Stand_7_CharacterName
 * @desc "立ち絵07"のキャラ名を設定
 *
 * @param Stand_7_FileName
 * @desc プラグインコマンドで"立ち絵07"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_8_PictureNumber
 * @desc "立ち絵08"のピクチャ番号を指定
 *
 * @param Stand_8_CharacterName
 * @desc "立ち絵08"のキャラ名を設定
 *
 * @param Stand_8_FileName
 * @desc プラグインコマンドで"立ち絵08"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_9_PictureNumber
 * @desc "立ち絵09"のピクチャ番号を指定
 *
 * @param Stand_9_CharacterName
 * @desc "立ち絵09"のキャラ名を設定
 *
 * @param Stand_9_FileName
 * @desc プラグインコマンドで"立ち絵09"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_10_PictureNumber
 * @desc "立ち絵10"のピクチャ番号を指定
 *
 * @param Stand_10_CharacterName
 * @desc "立ち絵10"のキャラ名を設定
 *
 * @param Stand_10_FileName
 * @desc プラグインコマンドで"立ち絵10"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_11_PictureNumber
 * @desc "立ち絵10"のピクチャ番号を指定
 *
 * @param Stand_11_CharacterName
 * @desc "立ち絵10"のキャラ名を設定
 *
 * @param Stand_11_FileName
 * @desc プラグインコマンドで"立ち絵10"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_12_PictureNumber
 * @desc "立ち絵10"のピクチャ番号を指定
 *
 * @param Stand_12_CharacterName
 * @desc "立ち絵10"のキャラ名を設定
 *
 * @param Stand_12_FileName
 * @desc プラグインコマンドで"立ち絵10"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_13_PictureNumber
 * @desc "立ち絵10"のピクチャ番号を指定
 *
 * @param Stand_13_CharacterName
 * @desc "立ち絵10"のキャラ名を設定
 *
 * @param Stand_13_FileName
 * @desc プラグインコマンドで"立ち絵10"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_14_PictureNumber
 * @desc "立ち絵10"のピクチャ番号を指定
 *
 * @param Stand_14_CharacterName
 * @desc "立ち絵10"のキャラ名を設定
 *
 * @param Stand_14_FileName
 * @desc プラグインコマンドで"立ち絵10"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_15_PictureNumber
 * @desc "立ち絵10"のピクチャ番号を指定
 *
 * @param Stand_15_CharacterName
 * @desc "立ち絵10"のキャラ名を設定
 *
 * @param Stand_15_FileName
 * @desc プラグインコマンドで"立ち絵10"を指定した際に呼び出す画像ファイル名
 *
 * @param Stand_16_PictureNumber
 * @desc "立ち絵10"のピクチャ番号を指定
 *
 * @param Stand_16_CharacterName
 * @desc "立ち絵10"のキャラ名を設定
 *
 * @param Stand_16_FileName
 * @desc プラグインコマンドで"立ち絵10"を指定した際に呼び出す画像ファイル名
 *
 * @help イベントコマンドの「プラグインコマンド」を使って立ち絵を表示・非表示させたり、
 *立ち絵に簡単なスライドアニメをさせます。
 *
 *--------------------------------------------------------------------------------------------------------------------------
 *
 * 【利用規約】
 * 1.利用上の注意
 * ・本スクリプトを使用してゲームなどを配布する際、
 *   添付ドキュメント内に本素材を使用して制作した旨を表記し、その際に次の権利表記を行なうこと。
 *
 *  (C)Altered  http://altered.sblo.jp
 *
 *   ※但し、「http://altered.sblo.jp」はR-18サイトのため、表記は配布者の任意としますが、
 *    本素材を使用した配布物が内容を問わずR-18指定の場合、表記は必須とします。
 *
 * ・有償、無償、年齢制限コンテンツでの利用に、特に制限はありません。
 *
 * ・利用に関しては全て自己責任で行ってください。
 *   本スクリプトを使用すること及びゲームなどを制作・配布・販売することにより、
 *   第三者との間で生じたトラブル等に関しては、本素材作成者は一切責任を負わないものとします。
 *
 * ・素材制作者に許可無く改変可。改変物の配布時には、
 *   添付ドキュメント内に本素材を使用して制作した旨を表記し、その際に次の権利表記を行なうこと。
 *
 *  (C)Altered  http://altered.sblo.jp
 *
 *   ※但し、「http://altered.sblo.jp」はR-18サイトのため、表記は配布者の任意としますが、
 *    本素材を使用した配布物が内容を問わずR-18指定の場合、表記は必須とします。
 *
 * 2.利用報告
 * ・特に必要ありません。
 *
 * 3.禁止事項
 * ・素材単体での二次配布。
 * ・素材への直リンク。
 *
 *  4.サポート
 * ・競合などの対処は致しかねますので、予めご了承下さい。
 *
 *--------------------------------------------------------------------------------------------------------------------------
 *
 * 【注意事項】
 * ・立ち絵画像の解像度の、縦横どちらか一方、もしくが両方が奇数の場合、
 *   拡大率100％でも表示した立ち絵画像がぼやけてしまう事がありますのでご注意下さい。
 *
 * ・画面解像度が、「816*624」「1024*768」「1280*960」以外の場合、
 *   スライドアニメが綺麗に表示されない場合があります。
 *
 * ・一度表示した立ち絵は、イベントコマンドの「ピクチャの移動」で対応するピクチャ番号を入力すれば動かせます。
 *   同様に、「ピクチャの消去」「ピクチャの回転」「ピクチャの色調変更」「ピクチャの消去」も使えます。
 *
 *
 * 【プラグインコマンド記述の仕方】
 * <記述1>
 * SPM キャラ名 立ち位置 スライド 時間 x y x％ y％ ウェイトありorなし
 *
 * <記述2>
 * SPM キャラ名 消去 時間 ウェイトありorなし
 *
 * ※1 それぞれの項目は半角スペースで区切って下さい。
 * ※2 キャラ名、ピクチャ番号、画像ファイル名の登録は、
 * 　　プラグイン管理画面のパラメータで予め設定しておいて下さい。
 * ※3 記述1で立ち絵が非表示になっても、ピクチャの透明度が0になっただけで画面上には存在しています。
 * 　　ピクチャを画面上から消去する場合は、任意のタイミングでイベントコマンド「ピクチャの消去」を実行して下さい。
 *
 *
 *
 * 【記述項目の説明】
 * <SPM>
 * このプラグインを呼び出すための記述です。必ず先頭に記述し、変更しないで下さい。
 *
 * <キャラ名>
 * 立ち絵を表示させたいキャラの名前をここに記述すると、
 * プラグイン管理画面のパラメータで設定した立ち絵画像が表示されます。
 *
 * <立ち位置>
 * 立ち絵を表示させたい位置を記述。
 * 　　　左…………立ち絵を画面の左側に表示させます。
 * 　　　右…………立ち絵を画面の左側に表示させます。
 * 　　　中央………立ち絵を画面の中央に表示させます。
 * 　　　前回………最後に表示した立ち位置に表示させます。
 * 　　　　　　　　※ゲームを再起動すると、"前回"の位置情報は消去されます。
 * 　　　　　　　　　ゲーム起動後、初めて表示させる際に"前回"を記述すると何も表示されません。
 *
 * <スライド>
 * 立ち絵が表示される際のスライドアニメの種類を記述。
 * 　　　なし………スライドせずに表示されます。
 * 　　　イン………中央に向かってスライドしながら、フェードインします。
 * 　　　　　　　　立ち位置によって右にスライドするか左にスライドするか、自動で判定します。
 * 　　　アウト……画面外に向かってスライドしながら、フェードアウトします。
 * 　　　　　　　　立ち位置によって右にスライドするか左にスライドするか、自動で判定します。
 *
 * <時間>
 * "スライド"の項目で設定したスライドアニメの処理時間（≒スライド＆フェード速度）を記述。
 * 値を"時間"と記述すると、各スライドパターン毎にオーソドックスな処理時間が自動で代入されます。
 *
 * <x>
 * 立ち位置で設定した位置に加え、ここに記述した値の分、さらに横方向に移動します。
 * 画面左に移動させる場合はマイナスの値を記述して下さい。
 *
 * <y>
 * プラグイン管理画面のパラメータ「default_position_y」で設定した画像の高さに加え、
 * ここに記述した値の分、さらに縦方向に移動します。
 * 画面上に移動させる場合はマイナスの値を記述して下さい。
 *
 * <x％>
 * 立ち絵画像の横の拡大率を指定します。
 * 画像を左右反転させる場合は<x％>に-100と記述して下さい。
 * 反転させる場合は画像の位置が線対称になるので、"x"項目で位置を調整して下さい。
 *
 * <y％>
 * 立ち絵画像の縦の拡大率を指定します。
 * 画像を上下逆さにする場合は<y％>に-100と記述して下さい。
 * 上下逆さにする場合は画像の位置が線対称になるので、"y"項目で位置を調整して下さい。
 *
 * <消去>
 * プラグインコマンドで指定したキャラ名の立ち絵画像を、非表示にする。
 *
 * <ウェイトありorなし>
 * スライドアニメやフェード処理をしている間、他の処理をウェイトするかどうかを指定します。
 * 　　　ウェイトあり……立ち絵のスライドアニメやフェード処理が終わるまで他の処理は待機します。
 * 　　　ウェイトなし……立ち絵のスライドアニメやフェード処理と他の処理が並列処理されます。
 *
 * ※プラグインコマンド記述の際、
 * 　"立ち位置" "スライド" "時間" "x" "y" "x％" "y％"の項目は、
 * 　その項目名のまま記述すると、デフォルト値として下記の値が各項目に代入されます。
 *
 * <デフォルト値>
 * 立ち位置 = 前回
 * スライド = なし
 * 時間 = スライドの種類に合わせてデフォルトで設定している値
 * 　　　　　　例）スライドの項目を"イン"と記述した場合、値は"10"が自動で代入される。
 * x = 0
 * y = 0
 * x％ = 100
 * y％ = 100
 *
 *
 *
 * 【使用例】
 * ▼例1▼
 * SPM アルド 左 イン 30 -25 y x％ y％ ウェイトなし
 *
 * 処理内容 :
 * プラグイン管理画面で設定したアルドに対応する画像ファイルが、同じくアルドに対応するピクチャ番号で、
 * 画面左側から30フーレムかけて中央に向かって少しスライドしながらフェードインし、
 * 最終立ち位置がプリセットの左側の立ち位置よりさらに左に25ドット寄っている。
 * （表示開始位置も左に25ドット寄った状態で開始される）
 * 以上の処理は、次の処理と並列に実行される。
 *
 * ▼例2▼
 * SPM アルド 消去 60 ウェイトなし
 * SPM ニナ 消去 60 ウェイトあり
 *
 * 処理内容 :
 * プラグイン管理画面で設定したアルドとニナそれぞれに対応するピクチャ番号の画像が、
 * 画面上から60フレームかけて同時にフェードアウトする。
 *
 *
 */

(function () {
  var parameters = PluginManager.parameters("ALT_StandingPictureMove");

  //パラメータをオブジェクトに格納

  var _default_position_y = String(parameters["default_position_y"] || 0);
  var default_position_y = _default_position_y - 0;

  $Stand_Character_FileName_obj = {};
  $Stand_Character_PictureNumber_obj = {};
  $SPM_Pic_x_obj = {};
  $SPM_Pic_y_obj = {};
  $SPM_Pic_Scale_x_obj = {};
  $SPM_Pic_Scale_y_obj = {};
  $SPM_Pic_Opacity_obj = {};
  $SPM_Pic_Position_obj = {};

  var SPM_NameNumber = 0;
  for (var i = 0; i < 16; i++) {
    SPM_NameNumber++;
    var _Stand_CharacterName = "Stand_" + SPM_NameNumber + "_CharacterName";
    var _Stand_FileName = "Stand_" + SPM_NameNumber + "_FileName";
    var _Stand_PictureNumber = "Stand_" + SPM_NameNumber + "_PictureNumber";
    var Stand_CharacterName = String(parameters[_Stand_CharacterName]);
    var Stand_FileName = String(parameters[_Stand_FileName]);
    var Stand_PictureNumber = String(parameters[_Stand_PictureNumber]);
    $Stand_Character_FileName_obj[Stand_CharacterName] = Stand_FileName;
    $Stand_Character_PictureNumber_obj[Stand_CharacterName] =
      Stand_PictureNumber;
  }

  var _Game_Interpreter_pluginCommand =
    Game_Interpreter.prototype.pluginCommand;
  Game_Interpreter.prototype.pluginCommand = function (command, args) {
    _Game_Interpreter_pluginCommand.call(this, command, args);
    if (command === "SPM") {
      //初期設定
      var SPM_Id = $Stand_Character_PictureNumber_obj[args[0]];
      var SPM_FileName = $Stand_Character_FileName_obj[args[0]];
      var SPM_Position = args[1];
      var _SPM_Position;

      var SPM_x = 0;
      var SPM_y = 0;

      //消去以外の処理
      if (SPM_Position !== "消去") {
        if (args[4] === "x") {
          args[4] = 0;
        }
        args[4] = args[4] - 0;

        switch (SPM_Position) {
          case "立ち位置":
            SPM_x = Graphics.width / 2 - Graphics.width / 3 + args[4];
            break;
          case "右":
            SPM_x = Graphics.width / 2 + Graphics.width / 3 + args[4];
            break;
          case "左":
            SPM_x = Graphics.width / 2 - Graphics.width / 3 + args[4];
            break;
          case "中央":
            SPM_x = Graphics.width / 2 + args[4];
            break;
          case "前回":
            SPM_x = $SPM_Pic_x_obj[SPM_Id] + args[4];
            break;
        }
        SPM_x = Math.round(SPM_x);

        if (args[5] === "y") {
          args[5] = 0;
        }
        args[5] = args[5] - 0;
        SPM_y = args[5] + default_position_y;

        if (args[6] === "x％") {
          args[6] = 100;
        }
        args[6] = args[6] - 0;
        SPM_Scale_x = args[6];

        if (args[7] === "y％") {
          args[7] = 100;
        }
        args[7] = args[7] - 0;
        SPM_Scale_y = args[7];

        //スライドアニメの初期設定
        var SPM_GraphicsWidth = Graphics.width;
        var SPM_GraphicCoefficient = 0;
        switch (SPM_GraphicsWidth) {
          case 816:
            SPM_GraphicCoefficient = 1;
            break;
          case 1024:
            SPM_GraphicCoefficient = 1.25;
            break;
          case 1280:
            SPM_GraphicCoefficient = 1.5;
            break;
        }

        var SPM_x_move = SPM_x;
        var SPM_y_move = SPM_y;
        var SPM_Scale_x_move = SPM_Scale_x;
        var SPM_Scale_y_move = SPM_Scale_y;
        var SPM_Opacity;
        var SPM_Duration;
        var SPM_SlidePattern = args[2];

        //スライドアニメの設定
        switch (SPM_SlidePattern) {
          case "スライド":
            switch (SPM_Position) {
              case "前回":
                _SPM_Position = $SPM_Pic_Position_obj[SPM_Id];
                break;
            }
            SPM_Opacity = 0;
            SPM_Opacity_move = 255;
            if (args[3] === "時間") {
              SPM_Duration = 10;
            } else if (args[3] !== "時間") {
              SPM_Duration = args[3];
            }
            break;

          case "なし":
            switch (SPM_Position) {
              case "前回":
                _SPM_Position = $SPM_Pic_Position_obj[SPM_Id];
                break;
            }
            SPM_Opacity = 0;
            SPM_Opacity_move = 255;
            if (args[3] === "時間") {
              SPM_Duration = 10;
            } else if (args[3] !== "時間") {
              SPM_Duration = args[3];
            }
            break;

          case "イン":
            switch (SPM_Position) {
              case "立ち位置":
                SPM_x += -10 * SPM_GraphicCoefficient;
                break;
              case "右":
                SPM_x += +10 * SPM_GraphicCoefficient;
                break;
              case "左":
                SPM_x += -10 * SPM_GraphicCoefficient;
                break;
              case "中央":
                alert(
                  "定位置以外でスライドさせたい場合は、立ち位置を'右'（or'左'）にして、プラグインコマンドの'x'に値を入れて調整して下さい"
                );
                break;
              case "前回":
                _SPM_Position = $SPM_Pic_Position_obj[SPM_Id];
                switch (_SPM_Position) {
                  case "立ち位置":
                    SPM_x_move += +10 * SPM_GraphicCoefficient;
                    break;
                  case "右":
                    SPM_x_move += -10 * SPM_GraphicCoefficient;
                    break;
                  case "左":
                    SPM_x_move += +10 * SPM_GraphicCoefficient;
                    break;
                  case "中央":
                    alert(
                      "定位置以外でスライドさせたい場合は、立ち位置を'右'（or'左'）にして、プラグインコマンドの'x'に値を入れて調整して下さい"
                    );
                    break;
                }
                break;
            }
            SPM_x_move = Math.round(SPM_x_move);

            SPM_Opacity = 0;
            SPM_Opacity_move = 255;
            if (args[3] === "時間") {
              SPM_Duration = 10;
            } else if (args[3] !== "時間") {
              SPM_Duration = args[3];
            }
            break;

          case "アウト":
            switch (SPM_Position) {
              case "立ち位置":
                SPM_x_move += -10 * SPM_GraphicCoefficient;
                break;
              case "右":
                SPM_x_move += +10 * SPM_GraphicCoefficient;
                break;
              case "左":
                SPM_x_move += -10 * SPM_GraphicCoefficient;
                break;
              case "中央":
                alert(
                  "定位置以外でスライドさせたい場合は、立ち位置を'右'（or'左'）にして、プラグインコマンドの'x'に値を入れて調整して下さい"
                );
                break;
              case "前回":
                _SPM_Position = $SPM_Pic_Position_obj[SPM_Id];
                switch (_SPM_Position) {
                  case "立ち位置":
                    SPM_x_move += -10 * SPM_GraphicCoefficient;
                    break;
                  case "右":
                    SPM_x_move += +10 * SPM_GraphicCoefficient;
                    break;
                  case "左":
                    SPM_x_move += -10 * SPM_GraphicCoefficient;
                    break;
                  case "中央":
                    alert(
                      "定位置以外でスライドさせたい場合は、立ち位置を'右'（or'左'）にして、プラグインコマンドの'x'に値を入れて調整して下さい"
                    );
                    break;
                }
                break;
            }
            SPM_x_move = Math.round(SPM_x_move);

            SPM_Opacity = 255;
            SPM_Opacity_move = 0;
            if (args[3] === "時間") {
              SPM_Duration = 10;
            } else if (args[3] !== "時間") {
              SPM_Duration = args[3];
            }
            break;
        }

        //ピクチャの移動 開始時の位置
        $gameScreen.showPicture(
          SPM_Id,
          SPM_FileName,
          1,
          SPM_x,
          SPM_y,
          SPM_Scale_x,
          SPM_Scale_y,
          SPM_Opacity,
          0
        );

        //ピクチャの移動 終了時の位置
        $gameScreen.movePicture(
          SPM_Id,
          1,
          SPM_x_move,
          SPM_y_move,
          SPM_Scale_x_move,
          SPM_Scale_y_move,
          SPM_Opacity_move,
          0,
          SPM_Duration
        );
        if (args[8] === "ウェイトあり") {
          this.wait(SPM_Duration);
        }

        //ピクチャの移動 終了時の位置の保存
        $SPM_Pic_x_obj[SPM_Id] = SPM_x_move;
        $SPM_Pic_y_obj[SPM_Id] = SPM_y_move;
        $SPM_Pic_Scale_x_obj[SPM_Id] = SPM_Scale_x_move;
        $SPM_Pic_Scale_y_obj[SPM_Id] = SPM_Scale_y_move;
        $SPM_Pic_Opacity_obj[SPM_Id] = SPM_Opacity_move;
        if (SPM_Position === "前回") {
          SPM_Position = _SPM_Position;
        }
        $SPM_Pic_Position_obj[SPM_Id] = SPM_Position;
      } //消去以外の処理 終了

      //消去処理
      if (SPM_Position === "消去") {
        var SPM_Id = $Stand_Character_PictureNumber_obj[args[0]];
        var SPM_Erase_x = $SPM_Pic_x_obj[SPM_Id];
        var SPM_Erase_y = $SPM_Pic_y_obj[SPM_Id];
        var SPM_Erase_Scale_x = $SPM_Pic_Scale_x_obj[SPM_Id];
        var SPM_Erase_Scale_y = $SPM_Pic_Scale_y_obj[SPM_Id];
        _SPM_Position = $SPM_Pic_Position_obj[SPM_Id];

        if (args[2] === "時間") {
          args[2] = 10;
        }
        var _SPM_Erase_Duration = args[2];
        var SPM_Erase_Duration = _SPM_Erase_Duration - 0;

        $gameScreen.movePicture(
          SPM_Id,
          1,
          SPM_Erase_x,
          SPM_Erase_y,
          SPM_Erase_Scale_x,
          SPM_Erase_Scale_y,
          0,
          0,
          SPM_Erase_Duration
        );

        if (args[3] === "ウェイトあり") {
          this.wait(SPM_Erase_Duration);
        }

        //処理終了時の位置の保存
        $SPM_Pic_x_obj[SPM_Id] = SPM_Erase_x;
        $SPM_Pic_y_obj[SPM_Id] = SPM_Erase_y;
        $SPM_Pic_Scale_x_obj[SPM_Id] = SPM_Erase_Scale_x;
        $SPM_Pic_Scale_y_obj[SPM_Id] = SPM_Erase_Scale_y;
        $SPM_Pic_Opacity_obj[SPM_Id] = 0;

        if (SPM_Position === "前回") {
          SPM_Position = _SPM_Position;
        }
      } // 消去処理  終了
    } // if (command === 'SPM')  終了
  }; // Game_Interpreter.prototype.pluginCommand  終了
})();


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);
  };
})();