pxt-common-packages 9.4.4 → 9.4.8

package/libs/game/hitbox.ts

@@ -1,21 +1,19 @@
 namespace game {
     export class Hitbox {
-        img: Image;
-        rev: number;
+        hash: Fx8;
         parent: Sprite;
         ox: Fx8;
         oy: Fx8;
         width: Fx8;
         height: Fx8;
 
-        constructor(parent: Sprite, width: number, height: number, ox: number, oy: number) {
-            this.img = parent.image;
-            this.rev = parent.image.revision();
+        constructor(parent: Sprite, width: Fx8, height: Fx8, ox: Fx8, oy: Fx8) {
+            this.hash = parent.calcDimensionalHash();
             this.parent = parent;
-            this.width = Fx8(width);
-            this.height = Fx8(height);
-            this.ox = Fx8(ox);
-            this.oy = Fx8(oy);
+            this.width = width;
+            this.height = height;
+            this.ox = ox;
+            this.oy = oy;
         }
 
         get left() {
@@ -41,7 +39,23 @@ namespace game {
         }
 
         isValid() {
-            return this.img === this.parent.image && this.rev === this.parent.image.revision();
+            return this.hash === this.parent.calcDimensionalHash();
+        }
+
+        contains(x: Fx8, y: Fx8): boolean {
+            return (x >= this.left) && (x <= this.right) && (y >= this.top) && (y <= this.bottom);
+        }
+
+        overlapsWith(other: Hitbox): boolean {
+            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;
         }
     }
 
@@ -51,24 +65,28 @@ namespace game {
             return s._hitbox;
 
         const i = s.image;
-        let minX = i.width;
-        let minY = i.height;
-        let maxX = 0;
-        let maxY = 0;
+        let minX = Fx8(i.width);
+        let minY = Fx8(i.height);
+        let maxX = Fx.zeroFx8;
+        let maxY = Fx.zeroFx8;
 
-        for (let c = 0; c < i.width; c++) {
-            for (let r = 0; r < i.height; r++) {
+        for (let c = 0, fxc = Fx.zeroFx8; c < i.width; c++, fxc = Fx.add(fxc, Fx.oneFx8)) {
+            for (let r = 0, fxr = Fx.zeroFx8; r < i.height; r++, fxr = Fx.add(fxr, Fx.oneFx8)) {
                 if (i.getPixel(c, r)) {
-                    minX = Math.min(minX, c);
-                    minY = Math.min(minY, r);
-                    maxX = Math.max(maxX, c);
-                    maxY = Math.max(maxY, r);
+                    minX = Fx.min(minX, fxc);
+                    minY = Fx.min(minY, fxr);
+                    maxX = Fx.max(maxX, fxc);
+                    maxY = Fx.max(maxY, fxr);
                 }
             }
         }
 
-        const width = maxX - minX + 1;
-        const height = maxY - minY + 1;
+        minX = Fx.mul(minX, s._sx);
+        minY = Fx.mul(minY, s._sy);
+        maxX = Fx.mul(maxX, s._sx);
+        maxY = Fx.mul(maxY, s._sy);
+        const width  = Fx.add(Fx.sub(maxX, minX), Fx.oneFx8);
+        const height = Fx.add(Fx.sub(maxY, minY), Fx.oneFx8);
 
         return new Hitbox(s, width, height, minX, minY);
     }

package/libs/game/renderText.ts

@@ -61,6 +61,8 @@ namespace sprites {
         }
 
         calculatePartialHeight(startLine: number, lengthToDraw: number) {
+            if (this.linebreaks.length === 0) return this.font.charHeight;
+
             let current = 0;
 
             for (let i = startLine; i < this.linebreaks.length + 1; i++) {
@@ -93,9 +95,9 @@ namespace sprites {
             return total;
         }
 
-        protected lineEnd(index: number) {
-            const prevEnd = index > 0 ? this.linebreaks[index - 1] : 0;
-            let end = index < this.linebreaks.length ? this.linebreaks[index] : this.text.length;
+        lineEnd(lineIndex: number) {
+            const prevEnd = lineIndex > 0 ? this.linebreaks[lineIndex - 1] : 0;
+            let end = lineIndex < this.linebreaks.length ? this.linebreaks[lineIndex] : this.text.length;
             let didMove = false;
 
             // Trim trailing whitespace
@@ -115,8 +117,8 @@ namespace sprites {
             return didMove ? end + 1 : end;
         }
 
-        protected lineStart(index: number) {
-            let start = index > 0 ? this.linebreaks[index - 1] : 0;
+        lineStart(lineIndex: number) {
+            let start = lineIndex > 0 ? this.linebreaks[lineIndex - 1] : 0;
 
             // Trim leading whitespace
             while (start < this.text.length) {
@@ -133,6 +135,29 @@ namespace sprites {
 
             return start;
         }
+
+        widthOfLine(lineIndex: number, fullTextOffset?: number) {
+            if (fullTextOffset != undefined) {
+                return (Math.min(this.lineEnd(lineIndex), fullTextOffset + 1) - this.lineStart(lineIndex)) * this.font.charWidth;
+            }
+            return (this.lineEnd(lineIndex) - this.lineStart(lineIndex)) * this.font.charWidth;
+        }
+
+        widthOfLines(lineStartIndex: number, lineEndIndex: number, offset?: number) {
+            if (this.linebreaks.length === 0) return this.widthOfLine(0, offset);
+
+            let width = 0;
+            let fullTextOffset: number;
+            for (let i = lineStartIndex; i < Math.min(lineEndIndex, this.linebreaks.length + 1); i++) {
+                if (offset != undefined) {
+                    fullTextOffset = this.lineStart(i) + offset;
+                    offset -= this.lineEnd(i) - this.lineStart(i);
+                }
+                if (fullTextOffset !== undefined && this.lineStart(i) > fullTextOffset) break;
+                width = Math.max(width, this.widthOfLine(i, fullTextOffset));
+            }
+            return width;
+        }
     }
 
 
@@ -203,6 +228,9 @@ namespace sprites {
         protected pageLine: number;
         protected timer: number;
         protected pauseMillis: number;
+        protected onTickCB: () => void;
+        protected onEndCB: () => void;
+        protected prevOffset: number;
 
         constructor(public text: RenderText, public height: number) {
             this.state = RenderTextAnimationState.Idle;
@@ -232,17 +260,21 @@ namespace sprites {
         }
 
         currentHeight() {
-            const maxHeight = Math.min(
-                Math.idiv(this.height, this.text.lineHeight()) + 1,
-                this.text.linebreaks.length + 1 - this.pageLine
-            ) * this.text.lineHeight();
+            const minHeight = this.text.lineHeight();
+            const maxHeight = Math.max(
+                Math.min(
+                    Math.idiv(this.height, this.text.lineHeight()) + 1,
+                    this.text.linebreaks.length + 1 - this.pageLine
+                ) * this.text.lineHeight(),
+                minHeight
+            );
 
 
             if (this.state === RenderTextAnimationState.Printing) {
-                return Math.min(
+                return Math.max(Math.min(
                     this.text.calculatePartialHeight(this.pageLine, this.currentOffset()),
                     maxHeight
-                );
+                ), minHeight)
             }
             else if (this.state === RenderTextAnimationState.Pausing) {
                 return maxHeight
@@ -252,10 +284,34 @@ namespace sprites {
             }
         }
 
+        currentWidth() {
+            return this.text.widthOfLines(
+                this.pageLine,
+                this.pageLine + Math.idiv(this.currentHeight(), this.text.lineHeight()) + 1,
+                this.state === RenderTextAnimationState.Printing ? this.currentOffset() : undefined
+            );
+        }
+
         currentOffset() {
             return Math.idiv(control.millis() - this.timer, this.tickPeriod)
         }
 
+        isDone() {
+            return this.state === RenderTextAnimationState.Idle;
+        }
+
+        cancel() {
+            this.state = RenderTextAnimationState.Idle;
+        }
+
+        onCharacterPrinted(cb: () => void) {
+            this.onTickCB = cb;
+        }
+
+        onAnimationEnd(cb: () => void) {
+            this.onEndCB = cb;
+        }
+
         draw(canvas: Image, left: number, top: number, color: number) {
             if (this.state === RenderTextAnimationState.Idle) return;
             else if (this.state === RenderTextAnimationState.Printing) {
@@ -269,6 +325,10 @@ namespace sprites {
                     this.pageLine + Math.idiv(this.height, this.text.lineHeight()) + 1
                 );
 
+                if (this.onTickCB && this.prevOffset !== this.currentOffset()) {
+                    this.onTickCB();
+                }
+
                 if (pageFinished) {
                     this.state = RenderTextAnimationState.Pausing;
                     this.timer = this.pauseMillis
@@ -290,6 +350,7 @@ namespace sprites {
                     this.pageLine += Math.idiv(this.height, this.text.lineHeight()) + 1;
                     if (this.pageLine > this.text.linebreaks.length) {
                         this.state = RenderTextAnimationState.Idle;
+                        if (this.onEndCB) this.onEndCB();
                     }
                     else {
                         this.state = RenderTextAnimationState.Printing;
@@ -297,6 +358,8 @@ namespace sprites {
                     }
                 }
             }
+
+            this.prevOffset = this.currentOffset();
         }
     }
 }

package/libs/game/sprite.ts

@@ -58,6 +58,36 @@ enum FlipOption {
     FlipXY
 }
 
+enum ScaleDirection {
+    //% block="vertically"
+    Vertically = 0x01,
+    //% block="horizontally"
+    Horizontally = 0x02,
+    //% block="uniformly"
+    Uniformly = Vertically | Horizontally,
+}
+
+enum ScaleAnchor {
+    //% block="middle"
+    Middle = 0,
+    //% block="top"
+    Top = 0x01,
+    //% block="left"
+    Left = 0x02,
+    //% block="right"
+    Right = 0x04,
+    //% block="bottom"
+    Bottom = 0x08,
+    //% block="top left"
+    TopLeft = Top | Left,
+    //% block="top right"
+    TopRight = Top | Right,
+    //% block="bottom left"
+    BottomLeft = Bottom | Left,
+    //% block="bottom right"
+    BottomRight = Bottom | Right,
+}
+
 /**
  * A sprite on the screen
  **/
@@ -71,27 +101,31 @@ class Sprite extends sprites.BaseSprite {
     _ay: Fx8
     _fx: Fx8 // friction
     _fy: Fx8 // friction
+    _sx: Fx8 // scale
+    _sy: Fx8 // scale
+    _width: Fx8 // scaled width
+    _height: Fx8 // scaled height
 
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="x" callInDebugger
     get x(): number {
-        return Fx.toFloat(this._x) + (this._image.width / 2)
+        return Fx.toFloat(Fx.add(this._x, Fx.div(this._width, Fx.twoFx8)));
     }
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="x"
     set x(v: number) {
-        this.left = v - (this._image.width / 2)
+        this.left = v - (this.width / 2)
     }
 
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="y" callInDebugger
     get y(): number {
-        return Fx.toFloat(this._y) + (this._image.height / 2)
+        return Fx.toFloat(Fx.add(this._y, Fx.div(this._height, Fx.twoFx8)));
     }
     //% group="Physics" blockSetVariable="mySprite"
     //% blockCombine block="y"
     set y(v: number) {
-        this.top = v - (this._image.height / 2)
+        this.top = v - (this.height / 2)
     }
 
     //% group="Physics" blockSetVariable="mySprite"
@@ -158,6 +192,42 @@ class Sprite extends sprites.BaseSprite {
     set fy(v: number) {
         this._fy = Fx8(Math.max(0, v))
     }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="sx (scale x)" callInDebugger
+    get sx(): number {
+        return Fx.toFloat(this._sx);
+    }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="sx (scale x)"
+    set sx(v: number) {
+        const x = this.x;
+        this._sx = Fx8(Math.max(0, v));
+        this.recalcSize();
+        this.left = x - this.width / 2;
+    }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="sy (scale y)" callInDebugger
+    get sy(): number {
+        return Fx.toFloat(this._sy);
+    }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="sy (scale y)"
+    set sy(v: number) {
+        const y = this.y;
+        this._sy = Fx8(Math.max(0, v));
+        this.recalcSize();
+        this.top = y - this.height / 2;
+    }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="scale" callInDebugger
+    get scale(): number {
+        return Math.max(this.sx, this.sy);
+    }
+    //% group="Physics" blockSetVariable="mySprite"
+    //% blockCombine block="scale"
+    set scale(v: number) {
+        this.sx = this.sy = v;
+    }
 
     private _data: any;
     /**
@@ -219,6 +289,8 @@ class Sprite extends sprites.BaseSprite {
         this.ay = 0
         this.fx = 0
         this.fy = 0
+        this._sx = Fx.oneFx8;
+        this._sy = Fx.oneFx8;
         this.flags = 0
         this.setImage(img);
         this.setKind(-1); // not a member of any type by default
@@ -229,7 +301,7 @@ class Sprite extends sprites.BaseSprite {
     }
 
     __serialize(offset: number): Buffer {
-        const buf = control.createBuffer(offset + 12);
+        const buf = control.createBuffer(offset + 16);
         let k = offset;
         buf.setNumber(NumberFormat.Int16LE, k, Fx.toInt(this._x)); k += 2;
         buf.setNumber(NumberFormat.Int16LE, k, Fx.toInt(this._y)); k += 2;
@@ -237,6 +309,8 @@ class Sprite extends sprites.BaseSprite {
         buf.setNumber(NumberFormat.Int16LE, k, Fx.toInt(this._vy)); k += 2;
         buf.setNumber(NumberFormat.Int16LE, k, Fx.toInt(this._ax)); k += 2;
         buf.setNumber(NumberFormat.Int16LE, k, Fx.toInt(this._ay)); k += 2;
+        buf.setNumber(NumberFormat.Int16LE, k, Fx.toInt(this._sx)); k += 2;
+        buf.setNumber(NumberFormat.Int16LE, k, Fx.toInt(this._sy)); k += 2;
         return buf;
     }
 
@@ -257,8 +331,17 @@ class Sprite extends sprites.BaseSprite {
     //% blockId=spritesetimage block="set %sprite(mySprite) image to %img=screen_image_picker"
     //% weight=7 help=sprites/sprite/set-image
     setImage(img: Image) {
-        if (!img) return; // don't break the sprite
+        if (!img || img === this._image) return;
         this._image = img;
+        this.recalcSize();
+    }
+
+    calcDimensionalHash() {
+        return Fx.mul(Fx.mul(this._width, this._height), Fx8(this._image.revision()));
+    }
+
+    resetHitbox() {
+        this._hitbox = null;
         this.setHitbox();
     }
 
@@ -311,19 +394,29 @@ class Sprite extends sprites.BaseSprite {
         return !(this.flags & SpriteFlag.Invisible);
     }
 
+    private recalcSize(): void {
+        this._width = Fx8(this._image.width * this.sx);
+        this._height = Fx8(this._image.height * this.sy);
+        this.resetHitbox();
+    }
+
+    private isScaled(): boolean {
+        return this._sx !== Fx.oneFx8 || this._sy !== Fx.oneFx8;
+    }
+
     //% group="Physics" blockSetVariable="mySprite"
-    //% blockCombine block="width"
+    //% blockCombine block="width" callInDebugger
     get width() {
-        return this._image.width
+        return Fx.toInt(this._width);
     }
     //% group="Physics" blockSetVariable="mySprite"
-    //% blockCombine block="height"
+    //% blockCombine block="height" callInDebugger
     get height() {
-        return this._image.height
+        return Fx.toInt(this._height);
     }
 
     //% group="Physics" blockSetVariable="mySprite"
-    //% blockCombine block="left"
+    //% blockCombine block="left" callInDebugger
     get left() {
         return Fx.toFloat(this._x)
     }
@@ -342,7 +435,7 @@ class Sprite extends sprites.BaseSprite {
     }
 
     //% group="Physics" blockSetVariable="mySprite"
-    //% blockCombine block="right"
+    //% blockCombine block="right" callInDebugger
     get right() {
         return this.left + this.width
     }
@@ -353,7 +446,7 @@ class Sprite extends sprites.BaseSprite {
     }
 
     //% group="Physics" blockSetVariable="mySprite"
-    //% blockCombine block="top"
+    //% blockCombine block="top" callInDebugger
     get top() {
         return Fx.toFloat(this._y);
     }
@@ -372,7 +465,7 @@ class Sprite extends sprites.BaseSprite {
     }
 
     //% group="Physics" blockSetVariable="mySprite"
-    //% blockCombine block="bottom"
+    //% blockCombine block="bottom" callInDebugger
     get bottom() {
         return this.top + this.height;
     }
@@ -576,7 +669,19 @@ class Sprite extends sprites.BaseSprite {
         const l = Math.floor(this.left - ox);
         const t = Math.floor(this.top - oy);
 
-        screen.drawTransparentImage(this._image, l, t)
+        if (!this.isScaled())
+            screen.drawTransparentImage(this._image, l, t);
+        else
+            screen.blit(
+                // dst rect in screen
+                l, t,
+                this.width,
+                this.height,
+                // src rect in sprite image
+                this._image,
+                0, 0,
+                this._image.width, this._image.height,
+                true, false);
 
         if (this.flags & SpriteFlag.ShowPhysics) {
             const font = image.font5;
@@ -697,7 +802,46 @@ class Sprite extends sprites.BaseSprite {
             return false
         if (other.flags & SPRITE_NO_SPRITE_OVERLAPS)
             return false
-        return other._image.overlapsWith(this._image, this.left - other.left, this.top - other.top)
+        if (!other._hitbox.overlapsWith(this._hitbox))
+            return false;
+        if (!this.isScaled() && !other.isScaled()) {
+            return other._image.overlapsWith(
+                this._image,
+                this.left - other.left,
+                this.top - other.top)
+        } else {
+            if (this.sx == 0 || this.sy == 0 || other.sx == 0 || other.sy == 0) return false;
+
+            let A: Sprite;
+            let B: Sprite;
+
+            // Render larger-scaled sprite onto smaller-scaled one so that we don't
+            // skip over source pixels in the check.
+
+            // A is the smaller-scaled sprite
+            if (this.sx * this.sy < other.sx * other.sy) {
+                A = this;
+                B = other;
+            } else {
+                A = other;
+                B = this;
+            }
+
+            // Render B onto A
+            return helpers.imageBlit(
+                A.image,
+                // Dst rect in A
+                (B.left - A.left) / A.sx,
+                (B.top - A.top) / A.sy,
+                B.width / A.sx,
+                B.height / A.sy,
+                B.image,
+                // Src rect in B
+                0, 0,
+                B.image.width,
+                B.image.height,
+                true, true);
+        }
     }
 
     /**
@@ -939,6 +1083,90 @@ class Sprite extends sprites.BaseSprite {
         }
     }
 
+    setScaleCore(sx?: number, sy?: number, anchor?: ScaleAnchor, proportional?: boolean): void {
+        anchor = anchor || ScaleAnchor.Middle;
+
+        const hasSx = sx != null;
+        const hasSy = sy != null;
+
+        const oldW = this.width;
+        const oldH = this.height;
+
+        if (hasSx) {
+            const oldSx = this.sx;
+            this.sx = sx;
+            if (!hasSy && proportional) {
+                const ratio = sx / oldSx;
+                this.sy *= ratio;
+            }
+        }
+        if (hasSy) {
+            const oldSy = this.sy;
+            this.sy = sy;
+            if (!hasSx && proportional) {
+                const ratio = sy / oldSy;
+                this.sx *= ratio;
+            }
+        }
+
+        if (anchor & (ScaleAnchor.Left | ScaleAnchor.Right)) {
+            const newW = this.width;
+            const diff = newW - oldW;
+            const diffOver2 = (diff / 2) | 0;
+            if (anchor & ScaleAnchor.Left) { this.x += diffOver2; }
+            if (anchor & ScaleAnchor.Right) { this.x -= diffOver2; }
+        }
+        if (anchor & (ScaleAnchor.Top | ScaleAnchor.Bottom)) {
+            const newH = this.height;
+            const diff = newH - oldH;
+            const diffOver2 = (diff / 2) | 0;
+            if (anchor & ScaleAnchor.Top) { this.y += diffOver2; }
+            if (anchor & ScaleAnchor.Bottom) { this.y -= diffOver2; }
+        }
+    }
+
+    //% blockId=sprite_set_scale
+    //% block="set %sprite(mySprite) scale to $value anchor $anchor"
+    //% expandableArgumentMode=enabled
+    //% inlineInputMode=inline
+    //% value.defl=1
+    //% anchor.defl=ScaleAnchor.Middle
+    //% help=sprites/sprite/set-scale
+    //% group="Scale" weight=90
+    setScale(value: number, anchor?: ScaleAnchor): void {
+        const direction = ScaleDirection.Uniformly;
+        anchor = anchor || ScaleAnchor.Middle;
+
+        let sx: number;
+        let sy: number;
+
+        if (direction & ScaleDirection.Horizontally) sx = value;
+        if (direction & ScaleDirection.Vertically) sy = value;
+
+        this.setScaleCore(sx, sy, anchor);
+    }
+
+    //% blockId=sprite_change_scale
+    //% block="change %sprite(mySprite) scale by $value anchor $anchor"
+    //% expandableArgumentMode=enabled
+    //% inlineInputMode=inline
+    //% value.defl=1
+    //% anchor.defl=ScaleAnchor.Middle
+    //% help=sprites/sprite/change-scale
+    //% group="Scale" weight=90
+    changeScale(value: number, anchor?: ScaleAnchor): void {
+        const direction = ScaleDirection.Uniformly;
+        anchor = anchor || ScaleAnchor.Middle;
+
+        let sx: number;
+        let sy: number;
+
+        if (direction & ScaleDirection.Horizontally) sx = this.sx + value;
+        if (direction & ScaleDirection.Vertically) sy = this.sy + value;
+
+        this.setScaleCore(sx, sy, anchor);
+    }
+
     toString() {
         return `${this.id}(${this.x},${this.y})->(${this.vx},${this.vy})`;
     }