pxt-arcade 2.0.45 → 2.1.2

package/built/common-sim.d.ts

@@ -1256,6 +1256,10 @@ declare namespace pxsim.ImageMethods {
     function blitRow(img: RefImage, x: number, y: number, from: RefImage, fromX: number, fromH: number): void;
     function _blit(img: RefImage, src: RefImage, args: RefCollection): boolean;
     function blit(dst: RefImage, src: RefImage, args: RefCollection): boolean;
+    function _drawScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection): void;
+    function drawScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection): void;
+    function _checkOverlapsScaledRotatedImage(dst: RefImage, src: RefImage, args: RefCollection): boolean;
+    function _checkOverlapsTwoScaledRotatedImages(dst: RefImage, src: RefImage, args: RefCollection): boolean;
 }
 declare namespace pxsim.image {
     function byteHeight(h: number, bpp: number): number;

package/built/common-sim.js

@@ -4977,6 +4977,281 @@ var pxsim;
             return false;
         }
         ImageMethods.blit = blit;
+        const TWO_PI = 2 * Math.PI;
+        const HALF_PI = Math.PI / 2;
+        const THREE_HALF_PI = 3 * Math.PI / 2;
+        const FX_ONE = 1;
+        function fxMul(a, b) {
+            return (a * b);
+        }
+        function fxDiv(a, b) {
+            return a / b;
+        }
+        function fxToInt(v) {
+            return v;
+        }
+        function fxFloor(v) {
+            return v | 0;
+        }
+        function parseShearArgs(src, args, argIndex) {
+            const parsed = {
+                sx: 0,
+                sy: 0,
+                scaledWidth: 0,
+                scaledHeight: 0,
+                minX: 0,
+                minY: 0,
+                maxX: 0,
+                maxY: 0,
+                xShear: 0,
+                yShear: 0,
+                flip: false
+            };
+            const sx = (args.getAt(argIndex) * FX_ONE);
+            const sy = (args.getAt(argIndex + 1) * FX_ONE);
+            let angle = args.getAt(argIndex + 2);
+            parsed.sx = sx;
+            parsed.sy = sy;
+            if (sx <= 0 || sy <= 0) {
+                return parsed;
+            }
+            angle %= TWO_PI;
+            if (angle < 0) {
+                angle += TWO_PI;
+            }
+            let flip = false;
+            if (angle > HALF_PI && angle <= THREE_HALF_PI) {
+                flip = true;
+                angle = (angle + Math.PI) % TWO_PI;
+            }
+            const xShear = (-Math.tan(angle / 2) * FX_ONE);
+            const yShear = (Math.sin(angle) * FX_ONE);
+            const scaledWidth = src._width * sx;
+            const scaledHeight = src._height * sy;
+            let shearedX = 0;
+            let shearedY = 0;
+            const SHEAR = (x, y) => {
+                shearedX = fxFloor(x + fxMul(y, xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, xShear));
+            };
+            SHEAR(0, 0);
+            let minX = shearedX;
+            let minY = shearedY;
+            let maxX = shearedX;
+            let maxY = shearedY;
+            SHEAR(scaledWidth - FX_ONE, 0);
+            minX = Math.min(minX, shearedX);
+            minY = Math.min(minY, shearedY);
+            maxX = Math.max(maxX, shearedX);
+            maxY = Math.max(maxY, shearedY);
+            SHEAR(scaledWidth - FX_ONE, scaledHeight - FX_ONE);
+            minX = Math.min(minX, shearedX);
+            minY = Math.min(minY, shearedY);
+            maxX = Math.max(maxX, shearedX);
+            maxY = Math.max(maxY, shearedY);
+            SHEAR(0, scaledHeight - FX_ONE);
+            minX = Math.min(minX, shearedX);
+            minY = Math.min(minY, shearedY);
+            maxX = Math.max(maxX, shearedX);
+            maxY = Math.max(maxY, shearedY);
+            parsed.minX = minX;
+            parsed.minY = minY;
+            parsed.maxX = maxX;
+            parsed.maxY = maxY;
+            parsed.scaledWidth = scaledWidth;
+            parsed.scaledHeight = scaledHeight;
+            parsed.xShear = xShear;
+            parsed.yShear = yShear;
+            parsed.flip = flip;
+            return parsed;
+        }
+        function _drawScaledRotatedImage(dst, src, args) {
+            drawScaledRotatedImage(dst, src, args);
+        }
+        ImageMethods._drawScaledRotatedImage = _drawScaledRotatedImage;
+        function drawScaledRotatedImage(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            if (xDst >= dst._width || yDst >= dst._height) {
+                return;
+            }
+            const shearArgs = parseShearArgs(src, args, 2);
+            if (shearArgs.sx <= 0 ||
+                shearArgs.sy <= 0 ||
+                xDst + fxToInt(shearArgs.maxX - shearArgs.minX) < 0 ||
+                yDst + fxToInt(shearArgs.maxY - shearArgs.minY) < 0) {
+                return;
+            }
+            let shearedX = 0;
+            let shearedY = 0;
+            const SHEAR = (x, y) => {
+                shearedX = fxFloor(x + fxMul(y, shearArgs.xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, shearArgs.yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, shearArgs.xShear));
+            };
+            dst.makeWritable();
+            if (shearArgs.flip) {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv((shearArgs.scaledWidth - x - FX_ONE), shearArgs.sx)), fxToInt(fxDiv((shearArgs.scaledHeight - y - FX_ONE), shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        setPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY), color);
+                    }
+                }
+            }
+            else {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv(x, shearArgs.sx)), fxToInt(fxDiv(y, shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        setPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY), color);
+                    }
+                }
+            }
+        }
+        ImageMethods.drawScaledRotatedImage = drawScaledRotatedImage;
+        function _checkOverlapsScaledRotatedImage(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            if (xDst >= dst._width || yDst >= dst._height) {
+                return false;
+            }
+            const shearArgs = parseShearArgs(src, args, 2);
+            if (shearArgs.sx <= 0 ||
+                shearArgs.sy <= 0 ||
+                xDst + fxToInt(shearArgs.maxX - shearArgs.minX) < 0 ||
+                yDst + fxToInt(shearArgs.maxY - shearArgs.minY) < 0) {
+                return false;
+            }
+            let shearedX = 0;
+            let shearedY = 0;
+            const SHEAR = (x, y) => {
+                shearedX = fxFloor(x + fxMul(y, shearArgs.xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, shearArgs.yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, shearArgs.xShear));
+            };
+            if (shearArgs.flip) {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv((shearArgs.scaledWidth - x - FX_ONE), shearArgs.sx)), fxToInt(fxDiv((shearArgs.scaledHeight - y - FX_ONE), shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        if (getPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            else {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv(x, shearArgs.sx)), fxToInt(fxDiv(y, shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        if (getPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        ImageMethods._checkOverlapsScaledRotatedImage = _checkOverlapsScaledRotatedImage;
+        function _checkOverlapsTwoScaledRotatedImages(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            const dstArgs = parseShearArgs(dst, args, 2);
+            if (dstArgs.sx <= 0 ||
+                dstArgs.sy <= 0 ||
+                xDst >= dstArgs.maxX - dstArgs.minX ||
+                yDst >= dstArgs.maxY - dstArgs.minY) {
+                return false;
+            }
+            const srcArgs = parseShearArgs(src, args, 5);
+            if (srcArgs.sx <= 0 ||
+                srcArgs.sy <= 0 ||
+                xDst + srcArgs.maxX - srcArgs.minX < 0 ||
+                yDst + srcArgs.maxY - srcArgs.minY < 0) {
+                return false;
+            }
+            let shearedX = 0;
+            let shearedY = 0;
+            let unshearedX = 0;
+            let unshearedY = 0;
+            const SHEAR = (x, y, xShear, yShear) => {
+                shearedX = fxFloor(x + fxMul(y, xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, xShear));
+            };
+            const REVERSE_SHEAR = (x, y, xShear, yShear) => {
+                unshearedX = fxFloor(x - fxMul(y, xShear));
+                unshearedY = fxFloor(y - fxMul(unshearedX, yShear));
+                unshearedX = fxFloor(unshearedX - fxMul(unshearedY, xShear));
+            };
+            if (srcArgs.flip) {
+                for (let y = 0; y < srcArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < srcArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv((srcArgs.scaledWidth - x - FX_ONE), srcArgs.sx)), fxToInt(fxDiv((srcArgs.scaledHeight - y - FX_ONE), srcArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y, srcArgs.xShear, srcArgs.yShear);
+                        const screenX = xDst + shearedX - srcArgs.minX;
+                        const screenY = yDst + shearedY - srcArgs.minY;
+                        if (screenX < 0 ||
+                            screenY < 0 ||
+                            screenX >= dstArgs.maxX - dstArgs.minX ||
+                            screenY >= dstArgs.maxY - dstArgs.minY) {
+                            continue;
+                        }
+                        REVERSE_SHEAR(screenX + dstArgs.minX, screenY + dstArgs.minY, dstArgs.xShear, dstArgs.yShear);
+                        if (dstArgs.flip) {
+                            if (getPixel(dst, fxToInt(fxDiv(dstArgs.scaledWidth - unshearedX - FX_ONE, dstArgs.sx)), fxToInt(fxDiv(dstArgs.scaledHeight - unshearedY - FX_ONE, dstArgs.sy)))) {
+                                return true;
+                            }
+                        }
+                        else if (getPixel(dst, fxToInt(fxDiv(unshearedX, dstArgs.sx)), fxToInt(fxDiv(unshearedY, dstArgs.sy)))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            else {
+                for (let y = 0; y < srcArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < srcArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv(x, srcArgs.sx)), fxToInt(fxDiv(y, srcArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y, srcArgs.xShear, srcArgs.yShear);
+                        const screenX = xDst + shearedX - srcArgs.minX;
+                        const screenY = yDst + shearedY - srcArgs.minY;
+                        if (screenX < 0 ||
+                            screenY < 0 ||
+                            screenX >= dstArgs.maxX - dstArgs.minX ||
+                            screenY >= dstArgs.maxY - dstArgs.minY) {
+                            continue;
+                        }
+                        REVERSE_SHEAR(screenX + dstArgs.minX, screenY + dstArgs.minY, dstArgs.xShear, dstArgs.yShear);
+                        if (dstArgs.flip) {
+                            if (getPixel(dst, fxToInt(fxDiv(dstArgs.scaledWidth - unshearedX - FX_ONE, dstArgs.sx)), fxToInt(fxDiv(dstArgs.scaledHeight - unshearedY - FX_ONE, dstArgs.sy)))) {
+                                return true;
+                            }
+                        }
+                        else if (getPixel(dst, fxToInt(fxDiv(unshearedX, dstArgs.sx)), fxToInt(fxDiv(unshearedY, dstArgs.sy)))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        ImageMethods._checkOverlapsTwoScaledRotatedImages = _checkOverlapsTwoScaledRotatedImages;
     })(ImageMethods = pxsim.ImageMethods || (pxsim.ImageMethods = {}));
 })(pxsim || (pxsim = {}));
 (function (pxsim) {

package/built/sim-strings.json

@@ -1 +1 @@
-{"Type your response using your keyboard and hit ENTER":"Type your response using your keyboard and hit ENTER","Unmute simulator":"Unmute simulator"}
+{"Type your response using your keyboard and hit ENTER":"Type your response using your keyboard and hit ENTER"}

package/built/sim.js

@@ -152,35 +152,6 @@ var pxsim;
     }
 })(pxsim || (pxsim = {}));
 var pxsim;
-(function (pxsim) {
-    const icon = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><!-- Font Awesome Pro 5.15.4 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license (Commercial License) --><path d="M215.03 71.05L126.06 160H24c-13.26 0-24 10.74-24 24v144c0 13.25 10.74 24 24 24h102.06l88.97 88.95c15.03 15.03 40.97 4.47 40.97-16.97V88.02c0-21.46-25.96-31.98-40.97-16.97zM461.64 256l45.64-45.64c6.3-6.3 6.3-16.52 0-22.82l-22.82-22.82c-6.3-6.3-16.52-6.3-22.82 0L416 210.36l-45.64-45.64c-6.3-6.3-16.52-6.3-22.82 0l-22.82 22.82c-6.3 6.3-6.3 16.52 0 22.82L370.36 256l-45.63 45.63c-6.3 6.3-6.3 16.52 0 22.82l22.82 22.82c6.3 6.3 16.52 6.3 22.82 0L416 301.64l45.64 45.64c6.3 6.3 16.52 6.3 22.82 0l22.82-22.82c6.3-6.3 6.3-16.52 0-22.82L461.64 256z"/></svg>`;
-    // We only need to unmute from within the iframe once
-    let hasUnmuted = false;
-    function createMuteButton() {
-        const el = document.createElement("div");
-        el.setAttribute("id", "safari-mute-button-outer");
-        el.innerHTML = `
-            <button class="safari-mute-button">
-                ${icon}
-            </button>
-        `;
-        const button = el.firstElementChild;
-        button.setAttribute("title", pxsim.localization.lf("Unmute simulator"));
-        button.addEventListener("click", () => {
-            pxsim.AudioContextManager.mute(false);
-            pxsim.setParentMuteState("unmuted");
-            button.remove();
-            hasUnmuted = true;
-        });
-        return el;
-    }
-    pxsim.createMuteButton = createMuteButton;
-    function shouldShowMute() {
-        return isSafari() && !hasUnmuted;
-    }
-    pxsim.shouldShowMute = shouldShowMute;
-})(pxsim || (pxsim = {}));
-var pxsim;
 (function (pxsim) {
     let forcedUpdateLoop;
     let isFirstRunSafari = true;
@@ -259,13 +230,8 @@ var pxsim;
             //event.preventDefault();
             // map canvas coordinates to arcade screen coordinates
             const rect = canvas.getBoundingClientRect();
-            const aspectRatio = canvas.height / canvas.width;
-            const actualWidth = Math.min(rect.height / aspectRatio, rect.width);
-            const actualHeight = Math.min(rect.width * aspectRatio, rect.height);
-            let xOffset = (rect.width - actualWidth) / 2;
-            let yOffset = (rect.height - actualHeight) / 2;
-            const x = ((event.clientX - rect.left - xOffset) / actualWidth) * canvas.width;
-            const y = ((event.clientY - rect.top - yOffset) / actualHeight) * canvas.height;
+            const x = ((event.clientX - rect.left) / rect.width) * canvas.width;
+            const y = ((event.clientY - rect.top) / rect.height) * canvas.height;
             if (!isMultiplayerSession()) {
                 board().mouseState.onEvent(event, x, y);
             }
@@ -629,7 +595,6 @@ var pxsim;
         }
         resize() { }
         async initAsync(msg) {
-            var _a;
             this.runOptions = msg;
             this.stats = document.getElementById("debug-stats");
             this.stats.className = "stats no-select";
@@ -650,13 +615,6 @@ var pxsim;
             }
             this.setActivePlayer(msg.activePlayer, theme);
             this.updateStats();
-            if (((_a = msg.options) === null || _a === void 0 ? void 0 : _a.mpRole) !== "server") {
-                if (pxsim.shouldShowMute()) {
-                    document.body.appendChild(pxsim.createMuteButton());
-                    pxsim.AudioContextManager.mute(true);
-                    pxsim.setParentMuteState("disabled");
-                }
-            }
             let safariEnablePromise;
             if (isFirstRunSafari && !safariEnablePromise) {
                 const safariWarning = document.getElementById("safari-enable-game");
@@ -2672,6 +2630,281 @@ var pxsim;
             return false;
         }
         ImageMethods.blit = blit;
+        const TWO_PI = 2 * Math.PI;
+        const HALF_PI = Math.PI / 2;
+        const THREE_HALF_PI = 3 * Math.PI / 2;
+        const FX_ONE = 1;
+        function fxMul(a, b) {
+            return (a * b);
+        }
+        function fxDiv(a, b) {
+            return a / b;
+        }
+        function fxToInt(v) {
+            return v;
+        }
+        function fxFloor(v) {
+            return v | 0;
+        }
+        function parseShearArgs(src, args, argIndex) {
+            const parsed = {
+                sx: 0,
+                sy: 0,
+                scaledWidth: 0,
+                scaledHeight: 0,
+                minX: 0,
+                minY: 0,
+                maxX: 0,
+                maxY: 0,
+                xShear: 0,
+                yShear: 0,
+                flip: false
+            };
+            const sx = (args.getAt(argIndex) * FX_ONE);
+            const sy = (args.getAt(argIndex + 1) * FX_ONE);
+            let angle = args.getAt(argIndex + 2);
+            parsed.sx = sx;
+            parsed.sy = sy;
+            if (sx <= 0 || sy <= 0) {
+                return parsed;
+            }
+            angle %= TWO_PI;
+            if (angle < 0) {
+                angle += TWO_PI;
+            }
+            let flip = false;
+            if (angle > HALF_PI && angle <= THREE_HALF_PI) {
+                flip = true;
+                angle = (angle + Math.PI) % TWO_PI;
+            }
+            const xShear = (-Math.tan(angle / 2) * FX_ONE);
+            const yShear = (Math.sin(angle) * FX_ONE);
+            const scaledWidth = src._width * sx;
+            const scaledHeight = src._height * sy;
+            let shearedX = 0;
+            let shearedY = 0;
+            const SHEAR = (x, y) => {
+                shearedX = fxFloor(x + fxMul(y, xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, xShear));
+            };
+            SHEAR(0, 0);
+            let minX = shearedX;
+            let minY = shearedY;
+            let maxX = shearedX;
+            let maxY = shearedY;
+            SHEAR(scaledWidth - FX_ONE, 0);
+            minX = Math.min(minX, shearedX);
+            minY = Math.min(minY, shearedY);
+            maxX = Math.max(maxX, shearedX);
+            maxY = Math.max(maxY, shearedY);
+            SHEAR(scaledWidth - FX_ONE, scaledHeight - FX_ONE);
+            minX = Math.min(minX, shearedX);
+            minY = Math.min(minY, shearedY);
+            maxX = Math.max(maxX, shearedX);
+            maxY = Math.max(maxY, shearedY);
+            SHEAR(0, scaledHeight - FX_ONE);
+            minX = Math.min(minX, shearedX);
+            minY = Math.min(minY, shearedY);
+            maxX = Math.max(maxX, shearedX);
+            maxY = Math.max(maxY, shearedY);
+            parsed.minX = minX;
+            parsed.minY = minY;
+            parsed.maxX = maxX;
+            parsed.maxY = maxY;
+            parsed.scaledWidth = scaledWidth;
+            parsed.scaledHeight = scaledHeight;
+            parsed.xShear = xShear;
+            parsed.yShear = yShear;
+            parsed.flip = flip;
+            return parsed;
+        }
+        function _drawScaledRotatedImage(dst, src, args) {
+            drawScaledRotatedImage(dst, src, args);
+        }
+        ImageMethods._drawScaledRotatedImage = _drawScaledRotatedImage;
+        function drawScaledRotatedImage(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            if (xDst >= dst._width || yDst >= dst._height) {
+                return;
+            }
+            const shearArgs = parseShearArgs(src, args, 2);
+            if (shearArgs.sx <= 0 ||
+                shearArgs.sy <= 0 ||
+                xDst + fxToInt(shearArgs.maxX - shearArgs.minX) < 0 ||
+                yDst + fxToInt(shearArgs.maxY - shearArgs.minY) < 0) {
+                return;
+            }
+            let shearedX = 0;
+            let shearedY = 0;
+            const SHEAR = (x, y) => {
+                shearedX = fxFloor(x + fxMul(y, shearArgs.xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, shearArgs.yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, shearArgs.xShear));
+            };
+            dst.makeWritable();
+            if (shearArgs.flip) {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv((shearArgs.scaledWidth - x - FX_ONE), shearArgs.sx)), fxToInt(fxDiv((shearArgs.scaledHeight - y - FX_ONE), shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        setPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY), color);
+                    }
+                }
+            }
+            else {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv(x, shearArgs.sx)), fxToInt(fxDiv(y, shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        setPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY), color);
+                    }
+                }
+            }
+        }
+        ImageMethods.drawScaledRotatedImage = drawScaledRotatedImage;
+        function _checkOverlapsScaledRotatedImage(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            if (xDst >= dst._width || yDst >= dst._height) {
+                return false;
+            }
+            const shearArgs = parseShearArgs(src, args, 2);
+            if (shearArgs.sx <= 0 ||
+                shearArgs.sy <= 0 ||
+                xDst + fxToInt(shearArgs.maxX - shearArgs.minX) < 0 ||
+                yDst + fxToInt(shearArgs.maxY - shearArgs.minY) < 0) {
+                return false;
+            }
+            let shearedX = 0;
+            let shearedY = 0;
+            const SHEAR = (x, y) => {
+                shearedX = fxFloor(x + fxMul(y, shearArgs.xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, shearArgs.yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, shearArgs.xShear));
+            };
+            if (shearArgs.flip) {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv((shearArgs.scaledWidth - x - FX_ONE), shearArgs.sx)), fxToInt(fxDiv((shearArgs.scaledHeight - y - FX_ONE), shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        if (getPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            else {
+                for (let y = 0; y < shearArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < shearArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv(x, shearArgs.sx)), fxToInt(fxDiv(y, shearArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y);
+                        if (getPixel(dst, xDst + fxToInt(shearedX - shearArgs.minX), yDst + fxToInt(shearedY - shearArgs.minY))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        ImageMethods._checkOverlapsScaledRotatedImage = _checkOverlapsScaledRotatedImage;
+        function _checkOverlapsTwoScaledRotatedImages(dst, src, args) {
+            const xDst = args.getAt(0);
+            const yDst = args.getAt(1);
+            const dstArgs = parseShearArgs(dst, args, 2);
+            if (dstArgs.sx <= 0 ||
+                dstArgs.sy <= 0 ||
+                xDst >= dstArgs.maxX - dstArgs.minX ||
+                yDst >= dstArgs.maxY - dstArgs.minY) {
+                return false;
+            }
+            const srcArgs = parseShearArgs(src, args, 5);
+            if (srcArgs.sx <= 0 ||
+                srcArgs.sy <= 0 ||
+                xDst + srcArgs.maxX - srcArgs.minX < 0 ||
+                yDst + srcArgs.maxY - srcArgs.minY < 0) {
+                return false;
+            }
+            let shearedX = 0;
+            let shearedY = 0;
+            let unshearedX = 0;
+            let unshearedY = 0;
+            const SHEAR = (x, y, xShear, yShear) => {
+                shearedX = fxFloor(x + fxMul(y, xShear));
+                shearedY = fxFloor(y + fxMul(shearedX, yShear));
+                shearedX = fxFloor(shearedX + fxMul(shearedY, xShear));
+            };
+            const REVERSE_SHEAR = (x, y, xShear, yShear) => {
+                unshearedX = fxFloor(x - fxMul(y, xShear));
+                unshearedY = fxFloor(y - fxMul(unshearedX, yShear));
+                unshearedX = fxFloor(unshearedX - fxMul(unshearedY, xShear));
+            };
+            if (srcArgs.flip) {
+                for (let y = 0; y < srcArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < srcArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv((srcArgs.scaledWidth - x - FX_ONE), srcArgs.sx)), fxToInt(fxDiv((srcArgs.scaledHeight - y - FX_ONE), srcArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y, srcArgs.xShear, srcArgs.yShear);
+                        const screenX = xDst + shearedX - srcArgs.minX;
+                        const screenY = yDst + shearedY - srcArgs.minY;
+                        if (screenX < 0 ||
+                            screenY < 0 ||
+                            screenX >= dstArgs.maxX - dstArgs.minX ||
+                            screenY >= dstArgs.maxY - dstArgs.minY) {
+                            continue;
+                        }
+                        REVERSE_SHEAR(screenX + dstArgs.minX, screenY + dstArgs.minY, dstArgs.xShear, dstArgs.yShear);
+                        if (dstArgs.flip) {
+                            if (getPixel(dst, fxToInt(fxDiv(dstArgs.scaledWidth - unshearedX - FX_ONE, dstArgs.sx)), fxToInt(fxDiv(dstArgs.scaledHeight - unshearedY - FX_ONE, dstArgs.sy)))) {
+                                return true;
+                            }
+                        }
+                        else if (getPixel(dst, fxToInt(fxDiv(unshearedX, dstArgs.sx)), fxToInt(fxDiv(unshearedY, dstArgs.sy)))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            else {
+                for (let y = 0; y < srcArgs.scaledHeight; y += FX_ONE) {
+                    for (let x = 0; x < srcArgs.scaledWidth; x += FX_ONE) {
+                        let color = getPixel(src, fxToInt(fxDiv(x, srcArgs.sx)), fxToInt(fxDiv(y, srcArgs.sy)));
+                        if (!color)
+                            continue;
+                        SHEAR(x, y, srcArgs.xShear, srcArgs.yShear);
+                        const screenX = xDst + shearedX - srcArgs.minX;
+                        const screenY = yDst + shearedY - srcArgs.minY;
+                        if (screenX < 0 ||
+                            screenY < 0 ||
+                            screenX >= dstArgs.maxX - dstArgs.minX ||
+                            screenY >= dstArgs.maxY - dstArgs.minY) {
+                            continue;
+                        }
+                        REVERSE_SHEAR(screenX + dstArgs.minX, screenY + dstArgs.minY, dstArgs.xShear, dstArgs.yShear);
+                        if (dstArgs.flip) {
+                            if (getPixel(dst, fxToInt(fxDiv(dstArgs.scaledWidth - unshearedX - FX_ONE, dstArgs.sx)), fxToInt(fxDiv(dstArgs.scaledHeight - unshearedY - FX_ONE, dstArgs.sy)))) {
+                                return true;
+                            }
+                        }
+                        else if (getPixel(dst, fxToInt(fxDiv(unshearedX, dstArgs.sx)), fxToInt(fxDiv(unshearedY, dstArgs.sy)))) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+        ImageMethods._checkOverlapsTwoScaledRotatedImages = _checkOverlapsTwoScaledRotatedImages;
     })(ImageMethods = pxsim.ImageMethods || (pxsim.ImageMethods = {}));
 })(pxsim || (pxsim = {}));
 (function (pxsim) {