pxt-common-packages 12.3.2 → 12.3.3

package/libs/game/hitbox.ts

@@ -88,15 +88,15 @@ namespace game {
         overlapsWith(other: Hitbox): boolean {
             this.updateIfInvalid();
             other.updateIfInvalid();
-            if (this.contains(other.left, other.top)) return true;
-            if (this.contains(other.left, other.bottom)) return true;
-            if (this.contains(other.right, other.top)) return true;
-            if (this.contains(other.right, other.bottom)) return true;
-            if (other.contains(this.left, this.top)) return true;
-            if (other.contains(this.left, this.bottom)) return true;
-            if (other.contains(this.right, this.top)) return true;
-            if (other.contains(this.right, this.bottom)) return true;
-            return false;
+            if (
+                this.left > other.right ||
+                this.top > other.bottom ||
+                this.right < other.left ||
+                this.bottom < other.top
+            ) {
+                return false;
+            }
+            return true;
         }
     }
 
@@ -105,6 +105,10 @@ namespace game {
         if (s._hitbox && s._hitbox.isValid())
             return s._hitbox;
 
+        if (s._rotatedBBox) {
+            return new Hitbox(s, Fx8(s._rotatedBBox.width), Fx8(s._rotatedBBox.height), Fx.zeroFx8, Fx.zeroFx8);
+        }
+
         const i = s.image;
         let minX = Fx8(i.width);
         let minY = Fx8(i.height);

package/libs/game/pxt.json

@@ -14,6 +14,7 @@
         "hitbox.ts",
         "renderText.ts",
         "spritesay.ts",
+        "rotation.ts",
         "sprites.ts",
         "sprite.ts",
         "extendableSprite.ts",

package/libs/game/rotation.ts

@@ -0,0 +1,194 @@
+namespace sprites {
+    let aabbPoints: number[];
+
+    export class RotatedBoundingBox {
+        protected _rotation: number;
+        protected _width: number;
+        protected _height: number;
+
+        protected points: number[];
+        protected cornerDistance: number;
+        protected cornerAngle: number;
+
+        public get x0(): number {
+            return this.points[0];
+        }
+
+        public get y0(): number {
+            return this.points[1];
+        }
+
+        public get x1(): number {
+            return this.points[2];
+        }
+
+        public get y1(): number {
+            return this.points[3];
+        }
+
+        public get x2(): number {
+            return this.points[4];
+        }
+
+        public get y2(): number {
+            return this.points[5];
+        }
+
+        public get x3(): number {
+            return this.points[6];
+        }
+
+        public get y3(): number {
+            return this.points[7];
+        }
+
+        public get rotation() {
+            return this._rotation;
+        }
+
+        public set rotation(value: number) {
+            this.setRotation(value);
+        }
+
+        public get width() {
+            return this._width;
+        }
+
+        public get height() {
+            return this._height;
+        }
+
+        constructor(
+            public anchor: Sprite,
+            width: number,
+            height: number
+        ) {
+            this.points = [];
+            this._rotation = 0;
+            this.setDimensions(width, height);
+        }
+
+        setDimensions(width: number, height: number) {
+            width /= 2;
+            height /= 2;
+
+            this.cornerDistance = Math.sqrt(
+                width * width + height * height
+            );
+            this.cornerAngle = Math.atan2(height, width);
+            this.setRotation(this._rotation);
+        }
+
+        setRotation(angle: number) {
+            this._rotation = angle;
+            this.points[0] = Math.cos(this.cornerAngle + angle) * this.cornerDistance;
+            this.points[1] = Math.sin(this.cornerAngle + angle) * this.cornerDistance;
+            this.points[2] = Math.cos(Math.PI - this.cornerAngle + angle) * this.cornerDistance;
+            this.points[3] = Math.sin(Math.PI - this.cornerAngle + angle) * this.cornerDistance;
+            this.points[4] = Math.cos(Math.PI + this.cornerAngle + angle) * this.cornerDistance;
+            this.points[5] = Math.sin(Math.PI + this.cornerAngle + angle) * this.cornerDistance;
+            this.points[6] = Math.cos(angle - this.cornerAngle) * this.cornerDistance;
+            this.points[7] = Math.sin(angle - this.cornerAngle) * this.cornerDistance;
+            this.updateWidthHeight();
+        }
+
+        overlaps(other: RotatedBoundingBox): boolean {
+            return doRectanglesIntersect(
+                this.points,
+                this.anchor.x,
+                this.anchor.y,
+                other.points,
+                other.anchor.x,
+                other.anchor.y
+            );
+        }
+
+        overlapsAABB(left: number, top: number, right: number, bottom: number) {
+            if (!aabbPoints) {
+                aabbPoints = [];
+            }
+
+            aabbPoints[0] = left;
+            aabbPoints[1] = top;
+            aabbPoints[2] = right;
+            aabbPoints[3] = top;
+            aabbPoints[4] = right;
+            aabbPoints[5] = bottom;
+            aabbPoints[6] = left;
+            aabbPoints[7] = bottom;
+            return doRectanglesIntersect(
+                this.points,
+                this.anchor.x,
+                this.anchor.y,
+                aabbPoints,
+                0,
+                0
+            );
+        }
+
+        protected updateWidthHeight() {
+            let minX = this.points[0];
+            let maxX = minX;
+            let minY = this.points[1];
+            let maxY = minY;
+
+            for (let i = 2; i < 8; i += 2) {
+                minX = Math.min(minX, this.points[i]);
+                maxX = Math.max(maxX, this.points[i]);
+                minY = Math.min(minY, this.points[i + 1]);
+                maxY = Math.max(maxY, this.points[i + 1]);
+            }
+
+            this._width = (maxX - minX) | 0;
+            this._height = (maxY - minY) | 0;
+        }
+    }
+
+    // adapted from https://stackoverflow.com/questions/10962379/how-to-check-intersection-between-2-rotated-rectangles
+    // but optimized for rectangles
+    function doRectanglesIntersect(a: number[], ax: number, ay: number, b: number[], bx: number, by: number) {
+        return !(checkForNonIntersection(a, ax, ay, b, bx, by) || checkForNonIntersection(b, bx, by, a, ax, ay));
+    }
+
+    function checkForNonIntersection(a: number[], ax: number, ay: number, b: number[], bx: number, by: number) {
+        // we only need to check the first two sides because the
+        // normals are the same for the other two
+        for (let pointIndex = 0; pointIndex < 4; pointIndex += 2) {
+            const normalX = a[pointIndex + 3] - a[pointIndex + 1];
+            const normalY = a[pointIndex] - a[pointIndex + 2];
+
+            let minA: number = undefined;
+            let maxA: number = undefined;
+            let minB: number = undefined;
+            let maxB: number = undefined;
+
+            for (let i = 0; i < 8; i += 2) {
+                const projected = normalX * (a[i] + ax) + normalY * (a[i + 1] + ay);
+
+                if (minA === undefined || projected < minA) {
+                    minA = projected;
+                }
+                if (maxA == undefined || projected > maxA) {
+                    maxA = projected;
+                }
+            }
+
+            for (let i = 0; i < 8; i += 2) {
+                const projected = normalX * (b[i] + bx) + normalY * (b[i + 1] + by);
+
+                if (minB === undefined || projected < minB) {
+                    minB = projected;
+                }
+                if (maxB == undefined || projected > maxB) {
+                    maxB = projected;
+                }
+            }
+
+            if (maxA < minB || maxB < minA) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

package/libs/game/sprite.ts

@@ -105,6 +105,7 @@ class Sprite extends sprites.BaseSprite {
     _sy: Fx8 // scale
     _width: Fx8 // scaled width
     _height: Fx8 // scaled height
+    _rotatedBBox: sprites.RotatedBoundingBox;
 
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="x" callInDebugger
@@ -200,10 +201,12 @@ class Sprite extends sprites.BaseSprite {
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="sx (scale x)"
     set sx(v: number) {
+        const y = this.y;
         const x = this.x;
         this._sx = Fx8(Math.max(0, v));
         this.recalcSize();
-        this.left = x - this.width / 2;
+        this.y = y;
+        this.x = x;
     }
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="sy (scale y)" callInDebugger
@@ -214,10 +217,13 @@ class Sprite extends sprites.BaseSprite {
     //% blockCombine block="sy (scale y)"
     set sy(v: number) {
         const y = this.y;
+        const x = this.x;
         this._sy = Fx8(Math.max(0, v));
         this.recalcSize();
-        this.top = y - this.height / 2;
+        this.y = y;
+        this.x = x;
     }
+
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="scale" callInDebugger
     get scale(): number {
@@ -229,6 +235,36 @@ class Sprite extends sprites.BaseSprite {
         this.sx = this.sy = v;
     }
 
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="rotation (radians)" callInDebugger
+    get rotation(): number {
+        return this._rotatedBBox ? this._rotatedBBox.rotation : 0;
+    }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="rotation (radians)"
+    set rotation(v: number) {
+        const x = this.x;
+        const y = this.y;
+        if (!this._rotatedBBox) {
+            this._rotatedBBox = new sprites.RotatedBoundingBox(this, this.width, this.height);
+        }
+        this._rotatedBBox.setRotation(v);
+        this.recalcSize();
+        this.x = x;
+        this.y = y;
+    }
+
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="rotation (degrees)" callInDebugger
+    get rotationDegrees(): number {
+        return this.rotation * 180 / Math.PI;
+    }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="rotation (degrees)"
+    set rotationDegrees(v: number) {
+        this.rotation = v * Math.PI / 180;
+    }
+
     private _data: any;
     /**
      * Custom data
@@ -338,7 +374,7 @@ class Sprite extends sprites.BaseSprite {
     }
 
     calcDimensionalHash() {
-        return this._image.revision() + Fx.toIntShifted(this._width, 8) + Fx.toIntShifted(this._height, 16);
+        return this._image.revision() + Fx.toIntShifted(this._width, 8) + Fx.toIntShifted(this._height, 16) + this.rotation;
     }
 
     resetHitbox() {
@@ -363,8 +399,15 @@ class Sprite extends sprites.BaseSprite {
     }
 
     protected recalcSize(): void {
-        this._width = Fx8(this._image.width * this.sx);
-        this._height = Fx8(this._image.height * this.sy);
+        if (this._rotatedBBox) {
+            this._rotatedBBox.setDimensions(this._image.width * this.sx, this._image.height * this.sy);
+            this._width = Fx8(this._rotatedBBox.width);
+            this._height = Fx8(this._rotatedBBox.height);
+        }
+        else {
+            this._width = Fx8(this._image.width * this.sx);
+            this._height = Fx8(this._image.height * this.sy);
+        }
         this.resetHitbox();
     }
 
@@ -688,7 +731,7 @@ class Sprite extends sprites.BaseSprite {
     //% blockId=spriteoverlapswith block="%sprite(mySprite) overlaps with %other=variables_get(otherSprite)"
     //% help=sprites/sprite/overlaps-with
     //% weight=90
-    overlapsWith(other: Sprite) {
+    overlapsWith(other: Sprite): boolean {
         control.enablePerfCounter("overlapsCPP")
         if (other == this) return false;
         if (this.flags & SPRITE_NO_SPRITE_OVERLAPS)
@@ -699,7 +742,47 @@ class Sprite extends sprites.BaseSprite {
             return other._hitbox.overlapsWith(this._hitbox);
         if (!other._hitbox.overlapsWith(this._hitbox))
             return false;
-        if (!this.isScaled() && !other.isScaled()) {
+        else if (this._rotatedBBox) {
+            if (other._rotatedBBox) {
+                if (this._rotatedBBox.overlaps(other._rotatedBBox)) {
+                    return helpers.checkOverlapsTwoScaledRotatedImages(
+                        other.image,
+                        this.left - other.left,
+                        this.top - other.top,
+                        other.sx,
+                        other.sy,
+                        other.rotation,
+                        this.image,
+                        this.sx,
+                        this.sy,
+                        this.rotation
+                    );
+                }
+                else {
+                    return false;
+                }
+            }
+            else {
+                if (this._rotatedBBox.overlapsAABB(other.left, other.top, other.right, other.bottom)) {
+                    return helpers.checkOverlapsScaledRotatedImage(
+                        other.image,
+                        this.left - other.left,
+                        this.top - other.top,
+                        this.image,
+                        this.sx,
+                        this.sy,
+                        this.rotation
+                    );
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        else if (other._rotatedBBox) {
+            return other.overlapsWith(this);
+        }
+        else if (!this.isScaled() && !other.isScaled()) {
             return other._image.overlapsWith(
                 this._image,
                 this.left - other.left,
@@ -1117,7 +1200,18 @@ class Sprite extends sprites.BaseSprite {
     }
 
     protected drawSprite(drawLeft: number, drawTop: number) {
-        if (!this.isScaled())
+        if (this._rotatedBBox) {
+            helpers.imageDrawScaledRotated(
+                screen,
+                drawLeft,
+                drawTop,
+                this._image,
+                this.sx,
+                this.sy,
+                this.rotation
+            );
+        }
+        else if (!this.isScaled())
             screen.drawTransparentImage(this._image, drawLeft, drawTop);
         else
             screen.blit(

package/libs/lcd/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P48754(s) {
+function _main___P49440(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___48997 = (undefined);
-    globals._pollEventQueue___49010 = (undefined);
+    globals._intervals___49683 = (undefined);
+    globals._pollEventQueue___49696 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P48754.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
-_main___P48754.continuations = [  ]
+_main___P49440.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
+_main___P49440.continuations = [  ]
 
-function _main___P48754_mk(s) {
+function _main___P49440_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P48754, depth: s.depth + 1,
+        parent: s, fn: _main___P49440, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P48754_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P48754
+return _main___P49440
 })

package/libs/light-spectrum-sensor/built/debug/binary.js

@@ -1,4 +1,4 @@
-// total=2914 new=27.04% cached=0.00% other=72.96%
+// total=2922 new=27.21% cached=0.00% other=72.79%
 (function (ectx) {
 'use strict';
 const runtime = ectx.runtime;
@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P98605(s) {
+function _main___P100669(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___98848 = (undefined);
-    globals._pollEventQueue___98861 = (undefined);
+    globals._intervals___100912 = (undefined);
+    globals._pollEventQueue___100925 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P98605.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
-_main___P98605.continuations = [  ]
+_main___P100669.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
+_main___P100669.continuations = [  ]
 
-function _main___P98605_mk(s) {
+function _main___P100669_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P98605, depth: s.depth + 1,
+        parent: s, fn: _main___P100669, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P98605_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P98605
+return _main___P100669
 })

package/libs/lora/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P60067(s) {
+function _main___P60759(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___60310 = (undefined);
-    globals._pollEventQueue___60323 = (undefined);
+    globals._intervals___61002 = (undefined);
+    globals._pollEventQueue___61015 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P60067.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"lora.ts","functionName":"<main>","argumentNames":[]}
-_main___P60067.continuations = [  ]
+_main___P60759.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"lora.ts","functionName":"<main>","argumentNames":[]}
+_main___P60759.continuations = [  ]
 
-function _main___P60067_mk(s) {
+function _main___P60759_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P60067, depth: s.depth + 1,
+        parent: s, fn: _main___P60759, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P60067_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P60067
+return _main___P60759
 })

package/libs/matrix-keypad/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P192099(s) {
+function _main___P196907(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___192342 = (undefined);
-    globals._pollEventQueue___192355 = (undefined);
+    globals._intervals___197150 = (undefined);
+    globals._pollEventQueue___197163 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P192099.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"keypad.ts","functionName":"<main>","argumentNames":[]}
-_main___P192099.continuations = [  ]
+_main___P196907.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"keypad.ts","functionName":"<main>","argumentNames":[]}
+_main___P196907.continuations = [  ]
 
-function _main___P192099_mk(s) {
+function _main___P196907_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P192099, depth: s.depth + 1,
+        parent: s, fn: _main___P196907, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P192099_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P192099
+return _main___P196907
 })