在MZ中如何添加圆角矩形

funxlww

如题，比如说MZ自带会在各个选项中添加一个黑色半透明的矩形嘛，我就很好奇这个矩形能不能变成圆角矩形

gt50

可以改，改一个函数就行

小怪兽奇奇侠

肯定可以改，改哪个函数呢？

if216

改 Window.prototype._setRectPartsGeometry = function(sprite, srect, drect, m)  这个函数
怎么改我还不知，再一个默认是有角这个概念的，只是有自己取角的方式。

MH-Pride

直接跟系统一样用个圆角皮肤
js改圆角很麻烦 css就可以直接改
所以窗口矩形都是在
function Rectangle() {
    this.initialize(...arguments);
}

Rectangle.prototype = Object.create(PIXI.Rectangle.prototype);
Rectangle.prototype.constructor = Rectangle;

Rectangle.prototype.initialize = function(x, y, width, height) {
    PIXI.Rectangle.call(this, x, y, width, height);
};
然后他们都是基础PIXI.Rectangle.prototype
所以需要在这改
[pre lang="js"]var Rectangle = /** @class */ (function () {
            /**
             * @param {number} [x=0] - The X coordinate of the upper-left corner of the rectangle
             * @param {number} [y=0] - The Y coordinate of the upper-left corner of the rectangle
             * @param {number} [width=0] - The overall width of this rectangle
             * @param {number} [height=0] - The overall height of this rectangle
             */
            function Rectangle(x, y, width, height) {
                if (x === void 0) { x = 0; }
                if (y === void 0) { y = 0; }
                if (width === void 0) { width = 0; }
                if (height === void 0) { height = 0; }
                /**
                 * @member {number}
                 * @default 0
                 */
                this.x = Number(x);
                /**
                 * @member {number}
                 * @default 0
                 */
                this.y = Number(y);
                /**
                 * @member {number}
                 * @default 0
                 */
                this.width = Number(width);
                /**
                 * @member {number}
                 * @default 0
                 */
                this.height = Number(height);
                /**
                 * The type of the object, mainly used to avoid `instanceof` checks
                 *
                 * @member {number}
                 * @readOnly
                 * @default PIXI.SHAPES.RECT
                 * @see PIXI.SHAPES
                 */
                this.type = exports.SHAPES.RECT;
            }
            Object.defineProperty(Rectangle.prototype, "left", {
                /**
                 * returns the left edge of the rectangle
                 *
                 * @member {number}
                 */
                get: function () {
                    return this.x;
                },
                enumerable: true,
                configurable: true
            });
            Object.defineProperty(Rectangle.prototype, "right", {
                /**
                 * returns the right edge of the rectangle
                 *
                 * @member {number}
                 */
                get: function () {
                    return this.x + this.width;
                },
                enumerable: true,
                configurable: true
            });
            Object.defineProperty(Rectangle.prototype, "top", {
                /**
                 * returns the top edge of the rectangle
                 *
                 * @member {number}
                 */
                get: function () {
                    return this.y;
                },
                enumerable: true,
                configurable: true
            });
            Object.defineProperty(Rectangle.prototype, "bottom", {
                /**
                 * returns the bottom edge of the rectangle
                 *
                 * @member {number}
                 */
                get: function () {
                    return this.y + this.height;
                },
                enumerable: true,
                configurable: true
            });
            Object.defineProperty(Rectangle, "EMPTY", {
                /**
                 * A constant empty rectangle.
                 *
                 * @static
                 * @constant
                 * @member {PIXI.Rectangle}
                 * @return {PIXI.Rectangle} An empty rectangle
                 */
                get: function () {
                    return new Rectangle(0, 0, 0, 0);
                },
                enumerable: true,
                configurable: true
            });
            /**
             * Creates a clone of this Rectangle
             *
             * @return {PIXI.Rectangle} a copy of the rectangle
             */
            Rectangle.prototype.clone = function () {
                return new Rectangle(this.x, this.y, this.width, this.height);
            };
            /**
             * Copies another rectangle to this one.
             *
             * @param {PIXI.Rectangle} rectangle - The rectangle to copy from.
             * @return {PIXI.Rectangle} Returns itself.
             */
            Rectangle.prototype.copyFrom = function (rectangle) {
                this.x = rectangle.x;
                this.y = rectangle.y;
                this.width = rectangle.width;
                this.height = rectangle.height;
                return this;
            };
            /**
             * Copies this rectangle to another one.
             *
             * @param {PIXI.Rectangle} rectangle - The rectangle to copy to.
             * @return {PIXI.Rectangle} Returns given parameter.
             */
            Rectangle.prototype.copyTo = function (rectangle) {
                rectangle.x = this.x;
                rectangle.y = this.y;
                rectangle.width = this.width;
                rectangle.height = this.height;
                return rectangle;
            };
            /**
             * Checks whether the x and y coordinates given are contained within this Rectangle
             *
             * @param {number} x - The X coordinate of the point to test
             * @param {number} y - The Y coordinate of the point to test
             * @return {boolean} Whether the x/y coordinates are within this Rectangle
             */
            Rectangle.prototype.contains = function (x, y) {
                if (this.width <= 0 || this.height <= 0) {
                    return false;
                }
                if (x >= this.x && x < this.x + this.width) {
                    if (y >= this.y && y < this.y + this.height) {
                        return true;
                    }
                }
                return false;
            };
            /**
             * Pads the rectangle making it grow in all directions.
             * If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
             *
             * @param {number} [paddingX=0] - The horizontal padding amount.
             * @param {number} [paddingY=0] - The vertical padding amount.
             * @return {PIXI.Rectangle} Returns itself.
             */
            Rectangle.prototype.pad = function (paddingX, paddingY) {
                if (paddingX === void 0) { paddingX = 0; }
                if (paddingY === void 0) { paddingY = paddingX; }
                this.x -= paddingX;
                this.y -= paddingY;
                this.width += paddingX * 2;
                this.height += paddingY * 2;
                return this;
            };
            /**
             * Fits this rectangle around the passed one.
             *
             * @param {PIXI.Rectangle} rectangle - The rectangle to fit.
             * @return {PIXI.Rectangle} Returns itself.
             */
            Rectangle.prototype.fit = function (rectangle) {
                var x1 = Math.max(this.x, rectangle.x);
                var x2 = Math.min(this.x + this.width, rectangle.x + rectangle.width);
                var y1 = Math.max(this.y, rectangle.y);
                var y2 = Math.min(this.y + this.height, rectangle.y + rectangle.height);
                this.x = x1;
                this.width = Math.max(x2 - x1, 0);
                this.y = y1;
                this.height = Math.max(y2 - y1, 0);
                return this;
            };
            /**
             * Enlarges rectangle that way its corners lie on grid
             *
             * @param {number} [resolution=1] resolution
             * @param {number} [eps=0.001] precision
             * @return {PIXI.Rectangle} Returns itself.
             */
            Rectangle.prototype.ceil = function (resolution, eps) {
                if (resolution === void 0) { resolution = 1; }
                if (eps === void 0) { eps = 0.001; }
                var x2 = Math.ceil((this.x + this.width - eps) * resolution) / resolution;
                var y2 = Math.ceil((this.y + this.height - eps) * resolution) / resolution;
                this.x = Math.floor((this.x + eps) * resolution) / resolution;
                this.y = Math.floor((this.y + eps) * resolution) / resolution;
                this.width = x2 - this.x;
                this.height = y2 - this.y;
                return this;
            };
            /**
             * Enlarges this rectangle to include the passed rectangle.
             *
             * @param {PIXI.Rectangle} rectangle - The rectangle to include.
             * @return {PIXI.Rectangle} Returns itself.
             */
            Rectangle.prototype.enlarge = function (rectangle) {
                var x1 = Math.min(this.x, rectangle.x);
                var x2 = Math.max(this.x + this.width, rectangle.x + rectangle.width);
                var y1 = Math.min(this.y, rectangle.y);
                var y2 = Math.max(this.y + this.height, rectangle.y + rectangle.height);
                this.x = x1;
                this.width = x2 - x1;
                this.y = y1;
                this.height = y2 - y1;
                return this;
            };
            return Rectangle;[/pre]