pxt-common-packages 12.3.1 → 12.3.3

package/libs/game/docs/reference/sprites/on-overlap.md

@@ -12,7 +12,7 @@ An overlap with a sprite of a different or the same kind is detected. If you wan
 
 When an overlap is detected the sprite of the first kind is given to you in the **sprite** parameter of **handler**. The sprite for the second kind is in **otherSprite**.
 
-An overlap of two sprites is dectected when the first non-transparent pixel in the image of the first sprite overlaps the first non-transparent pixel of the second sprite. If a sprite has it's ``ghost`` flag set, any overlap with another sprite won't be noticed. Also, an overlap occurs even when the values of **Z** for the sprites are different.
+An overlap of two sprites is detected when the first non-transparent pixel in the image of the first sprite overlaps the first non-transparent pixel of the second sprite. If a sprite has it's ``ghost`` flag set, any overlap with another sprite won't be noticed. Also, an overlap occurs even when the values of **Z** for the sprites are different.
 
 ## Parameters
 
@@ -24,95 +24,22 @@ An overlap of two sprites is dectected when the first non-transparent pixel in t
 
 ## Example #example
 
-### Ghost bumper #ex1
-
-Create a ``Ghost`` sprite that is blasted by green balls. Let the balls go through the sprite until it's ``kind`` is changed to ``Mortal`` by pressing the **A** button. When the ``Ghost`` sprite is changed to ``Mortal``, any contact with the balls is detected in ``||sprites:on overlaps||``. Make the balls push the ``Mortal`` sprite off the screen.
+Create a ``Ghost`` sprite that is blasted by yellow balls. Let the balls go through the sprite until it's ghost status is removed by pressing the **A** button. When the ``Ghost`` sprite is exposed, any contact with the balls is detected in ``||sprites:on overlap||``. Make the balls push the ``Ghost`` sprite off the screen.
 
 ```blocks
-namespace SpriteKind {
-    export const Mortal = SpriteKind.create()
-    export const Ghost = SpriteKind.create()
-    export const Ball = SpriteKind.create()
-}
-let ghost: Sprite = null
-let projectile: Sprite = null
-ghost = sprites.create(img`
-. . . . . . d d d d d . . . . . 
-. . . d d d d 1 1 1 d d d . . . 
-. . d d 1 1 1 1 1 1 1 1 d d . . 
-. . d 1 1 1 1 1 1 1 1 1 1 d . . 
-. . d 1 1 1 1 1 1 1 1 1 1 d d . 
-. d d 1 1 1 f 1 1 1 f 1 1 1 d . 
-. d 1 1 1 1 1 1 1 1 1 1 1 1 d d 
-. d 1 1 1 1 1 1 1 1 1 1 1 1 1 d 
-. d 1 1 1 1 1 1 1 1 1 1 1 1 1 d 
-d d 1 1 1 1 1 1 f f 1 1 1 1 1 d 
-d 1 1 1 1 1 1 1 f f 1 1 1 1 1 d 
-d 1 1 1 1 1 1 1 1 1 1 1 1 1 1 d 
-d 1 1 1 1 1 1 1 d 1 1 1 1 1 1 d 
-d 1 d d d 1 1 d d d d 1 d 1 1 d 
-d d d . d d d d . . d d d d d d 
-d d . . . d d . . . . d . . d d 
-`, SpriteKind.Ghost)
-ghost.x = 40
-ghost.setFlag(SpriteFlag.AutoDestroy, true)
-game.onUpdateInterval(400, function () {
-    projectile = sprites.createProjectile(img`
-. . 7 7 7 7 . . 
-. 7 7 7 7 7 7 . 
-7 7 7 7 7 7 7 7 
-7 7 7 7 7 7 7 7 
-7 7 7 7 7 7 7 7 
-7 7 7 7 7 7 7 7 
-. 7 7 7 7 7 7 . 
-. . 7 7 7 7 . . 
-`, -400, 0, SpriteKind.Ball)
-    projectile.z = -1
-})
-sprites.onOverlap(SpriteKind.Mortal, SpriteKind.Ball, function (sprite, otherSprite) {
-    sprite.say("Ouch!", 200)
-    otherSprite.vx = otherSprite.vx * -1
-    otherSprite.vy = Math.randomRange(-100, 100)
-    sprite.x += -1
-})
 controller.A.onEvent(ControllerButtonEvent.Pressed, function () {
-    ghost.setKind(SpriteKind.Mortal)
+    ghost.setFlag(SpriteFlag.Ghost, false)
 })
-sprites.onDestroyed(SpriteKind.Mortal, function (sprite) {
-    game.over()
+sprites.onOverlap(SpriteKind.Player, SpriteKind.Projectile, function (sprite, otherSprite) {
+    otherSprite.setVelocity(-50, 50)
+    sprite.sayText("Ouch!", 200, false)
+    sprite.setPosition(sprite.x + 2, sprite.y + 2)
+})
+sprites.onDestroyed(SpriteKind.Player, function (sprite) {
+    game.gameOver(false)
 })
-```
-
-## Ghosting mode #ex2
-
-Use the **A** to blast a green ball at a ``Ghost`` sprite. Set the flag for the sprite to ``Ghost``. In the ``||sprites:on overlaps||`` block, try to detect the contact of the ball with the ghost. When button **B** is pressed, switch the value of the ``ghost`` flag and see if the ball hits the ghost sprite.
-
-```blocks
-namespace SpriteKind {
-    export const Mortal = SpriteKind.create()
-    export const Ghost = SpriteKind.create()
-    export const Ball = SpriteKind.create()
-}
 let projectile: Sprite = null
 let ghost: Sprite = null
-let mySprite = sprites.create(img`
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    . . . . . . . . . . . . . . . . 
-    `, SpriteKind.Ball)
 ghost = sprites.create(img`
     . . . . . . d d d d d . . . . . 
     . . . d d d d 1 1 1 d d d . . . 
@@ -130,33 +57,29 @@ ghost = sprites.create(img`
     d 1 d d d 1 1 d d d d 1 d 1 1 d 
     d d d . d d d d . . d d d d d d 
     d d . . . d d . . . . d . . d d 
-    `, SpriteKind.Ghost)
-ghost.x = 40
+    `, SpriteKind.Player)
+ghost.setPosition(60, 60)
 ghost.setFlag(SpriteFlag.AutoDestroy, true)
-game.onUpdateInterval(400, function () {
-    projectile = sprites.createProjectile(img`
-        . . 7 7 7 7 . . 
-        . 7 7 7 7 7 7 . 
-        7 7 7 7 7 7 7 7 
-        7 7 7 7 7 7 7 7 
-        7 7 7 7 7 7 7 7 
-        7 7 7 7 7 7 7 7 
-        . 7 7 7 7 7 7 . 
-        . . 7 7 7 7 . . 
-        `, -400, 0, SpriteKind.Ball)
-    projectile.z = -1
-})
-controller.A.onEvent(ControllerButtonEvent.Pressed, function () {
-    ghost.setKind(SpriteKind.Mortal)
-})
-sprites.onDestroyed(SpriteKind.Mortal, function (sprite) {
-    game.over(false)
-})
-sprites.onOverlap(SpriteKind.Mortal, SpriteKind.Ball, function (sprite, otherSprite) {
-    sprite.say("Ouch!", 200)
-    otherSprite.vx = otherSprite.vx * -1
-    otherSprite.vy = Math.randomRange(-100, 100)
-    sprite.x += -1
+ghost.setFlag(SpriteFlag.Ghost, true)
+game.onUpdateInterval(1000, function () {
+    projectile = sprites.createProjectileFromSide(img`
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . 5 5 . . . . . . . 
+        . . . . . . 5 5 5 5 . . . . . . 
+        . . . . . 5 5 5 5 5 5 . . . . . 
+        . . . . . 5 5 5 5 5 5 . . . . . 
+        . . . . . . 5 5 5 5 . . . . . . 
+        . . . . . . . 5 5 . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        . . . . . . . . . . . . . . . . 
+        `, 50, 50)
 })
 ```
 

package/libs/game/docs/reference/sprites/sprite/say.md

@@ -42,28 +42,53 @@ f e e e e e f f f f f e e e e f
 smiley.say("Hello!")
 ```
 
-### Bounce message
+### Yellow message
 
-Send a sprite toward a barrier. When it contacts the barrier, have it bounce back to its starting position and briefly show the `"Bounce!"` caption.
+Make a square yellow sprite in the middle of the screen. Send a moving person sprite around the screen. When the person sprite crosses the yellow square, make the person say "Yellow!".
 
 ```blocks
-let greenBoxGo: Sprite = null
-let barrier: Sprite = null
-let shield: Image = null
-let greenBox: Image = null
-greenBox = image.create(32, 32)
-greenBox.fill(7)
-shield = image.create(4, 64)
-shield.fill(10)
-barrier = sprites.createObstacle(shield)
-barrier.x = scene.screenWidth() - 4
-greenBoxGo = sprites.create(greenBox)
-greenBoxGo.x = 16
-greenBoxGo.ax = 80
-greenBoxGo.onCollision(CollisionDirection.Right, function (wall) {
-    greenBoxGo.x = 16
-    greenBoxGo.say("Bounce!", 400)
+sprites.onOverlap(SpriteKind.Player, SpriteKind.Player, function (sprite, otherSprite) {
+    sprite.sayText("Yellow!", 100, false)
 })
+scene.setBackgroundColor(13)
+let box = sprites.create(img`
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 
+    `, SpriteKind.Player)
+let person = sprites.create(img`
+    . . . . . . f f f f . . . . . . 
+    . . . . f f f 2 2 f f f . . . . 
+    . . . f f f 2 2 2 2 f f f . . . 
+    . . f f f e e e e e e f f f . . 
+    . . f f e 2 2 2 2 2 2 e e f . . 
+    . . f e 2 f f f f f f 2 e f . . 
+    . . f f f f e e e e f f f f . . 
+    . f f e f b f 4 4 f b f e f f . 
+    . f e e 4 1 f d d f 1 4 e e f . 
+    . . f e e d d d d d d e e f . . 
+    . . . f e e 4 4 4 4 e e f . . . 
+    . . e 4 f 2 2 2 2 2 2 f 4 e . . 
+    . . 4 d f 2 2 2 2 2 2 f d 4 . . 
+    . . 4 4 f 4 4 5 5 4 4 f 4 4 . . 
+    . . . . . f f f f f f . . . . . 
+    . . . . . f f . . f f . . . . . 
+    `, SpriteKind.Player)
+person.setBounceOnWall(true)
+person.setVelocity(50, 50)
 ```
 
 ## #seealso

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(