pxt-common-packages 10.2.5 → 10.2.7

package/libs/game/controller.ts

@@ -164,7 +164,14 @@ namespace controller {
         //% group="Multiplayer"
         //% vx.shadow="spriteSpeedPicker"
         //% vy.shadow="spriteSpeedPicker"
+        //% parts="multiplayer"
         moveSprite(sprite: Sprite, vx: number = 100, vy: number = 100) {
+            this._moveSpriteInternal(sprite, vx, vy);
+        }
+
+        // use this instead of movesprite internally to avoid adding the "multiplayer" part
+        // to the compiled program
+        _moveSpriteInternal(sprite: Sprite, vx: number = 100, vy: number = 100) {
             if (!sprite) return;
             if (!this._controlledSprites) this._controlledSprites = [];
             let cp = this._controlledSprites.find(cp => cp.s.id == sprite.id);
@@ -193,6 +200,7 @@ namespace controller {
         //% blockId=ctrlonbuttonevent block="on %controller %button **button** %event"
         //% group="Multiplayer"
         //% help=controller/on-button-event
+        //% parts="multiplayer"
         onButtonEvent(btn: ControllerButton, event: ControllerButtonEvent, handler: () => void) {
             this.button(btn).onEvent(event, handler);
         }
@@ -206,6 +214,7 @@ namespace controller {
         //% blockId=ctrlonevent block="on %controller %event"
         //% group="Multiplayer"
         //% help=controller/on-event
+        //% parts="multiplayer"
         onEvent(event: ControllerEvent, handler: () => void) {
             control.onEvent(this.id, event, handler);
         }
@@ -227,6 +236,7 @@ namespace controller {
         //% weight=96 blockGap=8 help=controller/button/is-pressed
         //% blockId=ctrlispressed block="is %controller %button **button** pressed"
         //% group="Multiplayer"
+        //% parts="multiplayer"
         isPressed(btn: ControllerButton): boolean {
             return this.button(btn).isPressed();
         }
@@ -239,7 +249,14 @@ namespace controller {
         //% blockId=ctrldx block="%controller dx (left-right buttons)||scaled by %step"
         //% step.defl=100
         //% group="Multiplayer"
+        //% parts="multiplayer"
         dx(step: number = 100) {
+            return this._dxInternal(step);
+        }
+
+        // use this instead of dx internally to avoid adding the "multiplayer" part
+        // to the compiled program
+        _dxInternal(step: number = 100) {
             const ctx = control.eventContext();
             if (!ctx) return 0;
 
@@ -261,7 +278,14 @@ namespace controller {
         //% blockId=ctrldy block="%controller dy (up-down buttons)||scaled by %step"
         //% step.defl=100
         //% group="Multiplayer"
+        //% parts="multiplayer"
         dy(step: number = 100) {
+            return this._dyInternal(step);
+        }
+
+        // use this instead of dy internally to avoid adding the "multiplayer" part
+        // to the compiled program
+        _dyInternal(step: number = 100) {
             const ctx = control.eventContext();
             if (!ctx) return 0;
 
@@ -386,7 +410,7 @@ namespace controller {
     //% vx.shadow=spriteSpeedPicker
     //% vy.shadow=spriteSpeedPicker
     export function moveSprite(sprite: Sprite, vx: number = 100, vy: number = 100) {
-        _player1().moveSprite(sprite, vx, vy);
+        _player1()._moveSpriteInternal(sprite, vx, vy);
     }
 
     /**
@@ -398,7 +422,7 @@ namespace controller {
     //% step.defl=100
     //% group="Single Player"
     export function dx(step: number = 100) {
-        return _player1().dx(step);
+        return _player1()._dxInternal(step);
     }
 
     /**
@@ -410,7 +434,7 @@ namespace controller {
     //% step.defl=100
     //% group="Single Player"
     export function dy(step: number = 100) {
-        return _player1().dy(step);
+        return _player1()._dyInternal(step);
     }
 
     class AnyButton extends Button {

package/libs/game/info.ts

@@ -121,18 +121,18 @@ namespace info {
                     // First draw players
                     ps.forEach(p => p.drawPlayer());
                     // Then run life over events
-                    ps.forEach(p => p.raiseLifeZero(false));
+                    ps.forEach(p => p.impl.raiseLifeZero(false));
                 } else { // single player
                     // show score
                     const p = player1;
-                    if (p.hasScore() && (infoState.visibilityFlag & Visibility.Score)) {
+                    if (p.impl.hasScore() && (infoState.visibilityFlag & Visibility.Score)) {
                         p.drawScore();
                     }
                     // show life
-                    if (p.hasLife() && (infoState.visibilityFlag & Visibility.Life)) {
+                    if (p.impl.hasLife() && (infoState.visibilityFlag & Visibility.Life)) {
                         p.drawLives();
                     }
-                    p.raiseLifeZero(true);
+                    p.impl.raiseLifeZero(true);
                 }
                 // show countdown in both modes
                 if (infoState.gameEnd !== undefined && infoState.visibilityFlag & Visibility.Countdown) {
@@ -216,7 +216,7 @@ namespace info {
         const allScoresKey = "all-scores";
         let allScores: number[];
         if (players) {
-            allScores = players.filter(item => item.hasScore()).map(item => item.score());
+            allScores = players.filter(item => item.impl.hasScore()).map(item => item.impl.score());
         }
         else {
             allScores = [];
@@ -229,8 +229,8 @@ namespace info {
         if (players) {
             let hs = 0;
             players
-                .filter(p => p && p.hasScore())
-                .forEach(p => hs = Math.max(hs, p.score()));
+                .filter(p => p && p.impl.hasScore())
+                .forEach(p => hs = Math.max(hs, p.impl.score()));
             const curr = settings.readNumber("high-score")
             if (curr == null || hs > curr)
                 settings.writeNumber("high-score", hs);
@@ -245,13 +245,13 @@ namespace info {
     //% help=info/score
     //% group="Score"
     export function score() {
-        return player1.score();
+        return player1.impl.score();
     }
 
     //%
     //% group="Score"
     export function hasScore() {
-        return player1.hasScore();
+        return player1.impl.hasScore();
     }
 
     /**
@@ -273,7 +273,7 @@ namespace info {
     //% help=info/set-score
     //% group="Score"
     export function setScore(value: number) {
-        player1.setScore(value);
+        player1.impl.setScore(value);
     }
 
     /**
@@ -285,7 +285,7 @@ namespace info {
     //% help=info/change-score-by
     //% group="Score"
     export function changeScoreBy(value: number) {
-        player1.changeScoreBy(value);
+        player1.impl.changeScoreBy(value);
     }
 
     /**
@@ -296,12 +296,12 @@ namespace info {
     //% help=info/life
     //% group="Life"
     export function life() {
-        return player1.life();
+        return player1.impl.life();
     }
 
     //% group="Life"
     export function hasLife() {
-        return player1.hasLife();
+        return player1.impl.hasLife();
     }
 
     /**
@@ -313,7 +313,7 @@ namespace info {
     //% help=info/set-life
     //% group="Life"
     export function setLife(value: number) {
-        player1.setLife(value);
+        player1.impl.setLife(value);
     }
 
     /**
@@ -325,7 +325,7 @@ namespace info {
     //% help=info/change-life-by
     //% group="Life"
     export function changeLifeBy(value: number) {
-        player1.changeLifeBy(value);
+        player1.impl.changeLifeBy(value);
     }
 
     /**
@@ -337,7 +337,7 @@ namespace info {
     //% help=info/on-life-zero
     //% group="Life"
     export function onLifeZero(handler: () => void) {
-        player1.onLifeZero(handler);
+        player1.impl.onLifeZero(handler);
     }
 
     /**
@@ -355,7 +355,7 @@ namespace info {
     //% help=info/on-score
     //% group="Score"
     export function onScore(score: number, handler: () => void) {
-        player1.onScore(score, handler);
+        player1.impl.onScore(score, handler);
     }
 
     /**
@@ -564,9 +564,14 @@ namespace info {
         }
     }
 
-    //% fixedInstances
-    //% blockGap=8
-    export class PlayerInfo {
+    /**
+     * Splits the implementation of the player info from the user-facing APIs so that
+     * we can reference this internally without causing the "multiplayer" part to show
+     * up in the usedParts array of the user program's compile result. Make sure to
+     * use the APIs on this class and not the PlayerInfo to avoid false-positives when
+     * we detect if a game is multiplayer or not
+     */
+    export class PlayerInfoImpl {
         protected _player: number;
         public bg: number; // background color
         public border: number; // border color
@@ -614,9 +619,6 @@ namespace info {
                 this.left = true;
                 this.up = true;
             }
-
-            if (!players) players = [];
-            players[this._player - 1] = this;
         }
 
         private init() {
@@ -637,12 +639,6 @@ namespace info {
             return this._player;
         }
 
-        /**
-         * Get the player score
-         */
-        //% group="Multiplayer"
-        //% blockId=piscore block="%player score"
-        //% help=info/score
         score(): number {
             if (this.showScore === undefined) this.showScore = true;
             if (this.showPlayer === undefined) this.showPlayer = true;
@@ -654,13 +650,6 @@ namespace info {
             return state.score;
         }
 
-        /**
-         * Set the player score
-         */
-        //% group="Multiplayer"
-        //% blockId=pisetscore block="set %player score to %value"
-        //% value.defl=0
-        //% help=info/set-score
         setScore(value: number) {
             const state = this.getState();
             if (!(infoState.visibilityFlag & Visibility._ExplicitlySetScore)) {
@@ -680,6 +669,211 @@ namespace info {
             }
         }
 
+        changeScoreBy(value: number): void {
+            this.setScore(this.score() + value);
+        }
+
+        hasScore() {
+            const state = this.getState();
+            return state.score !== undefined;
+        }
+
+        life(): number {
+            const state = this.getState();
+            if (this.showLife === undefined) this.showLife = true;
+            if (this.showPlayer === undefined) this.showPlayer = true;
+
+            if (state.life === undefined) {
+                state.life = 3;
+            }
+            return state.life || 0;
+        }
+
+        setLife(value: number): void {
+            const state = this.getState();
+            if (!(infoState.visibilityFlag & Visibility._ExplicitlySetLife)) {
+                updateFlag(Visibility.Life, true);
+            }
+
+            this.life(); // invoked for side effects
+            state.life = (value | 0);
+        }
+
+        changeLifeBy(value: number): void {
+            this.setLife(this.life() + value);
+        }
+
+        hasLife(): boolean {
+            const state = this.getState();
+            return state.life !== undefined && state.life !== null;
+        }
+
+        onLifeZero(handler: () => void) {
+            const state = this.getState();
+            state.lifeZeroHandler = handler;
+        }
+
+        onScore(score: number, handler: () => void) {
+            const state = this.getState();
+            state.scoreReachedHandler = new ScoreReachedHandler(score, handler);
+        }
+
+        raiseLifeZero(gameOver: boolean) {
+            const state = this.getState();
+            if (state.life !== null && state.life <= 0) {
+                state.life = null;
+                if (state.lifeZeroHandler) {
+                    state.lifeZeroHandler();
+                } else if (gameOver) {
+                    game.over();
+                }
+            }
+        }
+    }
+
+    //% fixedInstances
+    //% blockGap=8
+    export class PlayerInfo {
+        protected _player: number;
+        public impl: PlayerInfoImpl;
+
+        constructor(player: number) {
+            this._player = player;
+            this.impl = new PlayerInfoImpl(player);
+
+            if (!players) players = [];
+            players[this._player - 1] = this;
+        }
+
+        private init() {
+            initHUD();
+            if (this._player > 1) initMultiHUD();
+            if (!infoState.playerStates[this._player - 1]) {
+                infoState.playerStates[this._player - 1] = new PlayerState();
+            }
+        }
+
+        get bg(): number {
+            return this.impl.bg;
+        }
+
+        set bg(value: number) {
+            this.impl.bg = value;
+        }
+
+        get border(): number {
+            return this.impl.border;
+        }
+
+        set border(value: number) {
+            this.impl.border = value;
+        }
+
+        get fc(): number {
+            return this.impl.fc;
+        }
+
+        set fc(value: number) {
+            this.impl.fc = value;
+        }
+
+        get showScore(): boolean {
+            return this.impl.showScore;
+        }
+
+        set showScore(value: boolean) {
+            this.impl.showScore = value;
+        }
+
+        get showLife(): boolean {
+            return this.impl.showLife;
+        }
+
+        set showLife(value: boolean) {
+            this.impl.showLife = value;
+        }
+
+        get visibility(): Visibility {
+            return this.impl.visibility;
+        }
+
+        set visibility(value: Visibility) {
+            this.impl.visibility = value;
+        }
+
+        get showPlayer(): boolean {
+            return this.impl.showPlayer;
+        }
+
+        set showPlayer(value: boolean) {
+            this.impl.showPlayer = value;
+        }
+
+        get x(): number {
+            return this.impl.x;
+        }
+
+        set x(value: number) {
+            this.impl.x = value;
+        }
+
+        get y(): number {
+            return this.impl.y;
+        }
+
+        set y(value: number) {
+            this.impl.y = value;
+        }
+
+        get left(): boolean {
+            return this.impl.left;
+        }
+
+        set left(value: boolean) {
+            this.impl.left = value;
+        }
+
+        get up(): boolean {
+            return this.impl.up;
+        }
+
+        set up(value: boolean) {
+            this.impl.up = value;
+        }
+
+        getState(): PlayerState {
+            this.init();
+            return infoState.playerStates[this._player - 1];
+        }
+
+        // the id numbera of the player
+        id(): number {
+            return this.impl.id();
+        }
+
+        /**
+         * Get the player score
+         */
+        //% group="Multiplayer"
+        //% blockId=piscore block="%player score"
+        //% help=info/score
+        //% parts="multiplayer"
+        score(): number {
+            return this.impl.score();
+        }
+
+        /**
+         * Set the player score
+         */
+        //% group="Multiplayer"
+        //% blockId=pisetscore block="set %player score to %value"
+        //% value.defl=0
+        //% help=info/set-score
+        //% parts="multiplayer"
+        setScore(value: number) {
+            this.impl.setScore(value);
+        }
+
         /**
          * Change the score of a player
          * @param value
@@ -688,13 +882,13 @@ namespace info {
         //% blockId=pichangescore block="change %player score by %value"
         //% value.defl=1
         //% help=info/change-score-by
+        //% parts="multiplayer"
         changeScoreBy(value: number): void {
-            this.setScore(this.score() + value);
+            this.impl.changeScoreBy(value);
         }
 
         hasScore() {
-            const state = this.getState();
-            return state.score !== undefined;
+            return this.impl.hasScore();
         }
 
         /**
@@ -703,15 +897,9 @@ namespace info {
         //% group="Multiplayer"
         //% blockid=piflife block="%player life"
         //% help=info/life
+        //% parts="multiplayer"
         life(): number {
-            const state = this.getState();
-            if (this.showLife === undefined) this.showLife = true;
-            if (this.showPlayer === undefined) this.showPlayer = true;
-
-            if (state.life === undefined) {
-                state.life = 3;
-            }
-            return state.life || 0;
+            return this.impl.life();
         }
 
         /**
@@ -721,14 +909,9 @@ namespace info {
         //% blockId=pisetlife block="set %player life to %value"
         //% value.defl=3
         //% help=info/set-life
+        //% parts="multiplayer"
         setLife(value: number): void {
-            const state = this.getState();
-            if (!(infoState.visibilityFlag & Visibility._ExplicitlySetLife)) {
-                updateFlag(Visibility.Life, true);
-            }
-
-            this.life(); // invoked for side effects
-            state.life = (value | 0);
+            this.impl.setLife(value);
         }
 
         /**
@@ -739,8 +922,9 @@ namespace info {
         //% blockId=pichangelife block="change %player life by %value"
         //% value.defl=-1
         //% help=info/change-life-by
+        //% parts="multiplayer"
         changeLifeBy(value: number): void {
-            this.setLife(this.life() + value);
+            this.impl.changeLifeBy(value);
         }
 
         /**
@@ -751,9 +935,9 @@ namespace info {
         //% group="Multiplayer"
         //% blockId=pihaslife block="%player has life"
         //% help=info/has-life
+        //% parts="multiplayer"
         hasLife(): boolean {
-            const state = this.getState();
-            return state.life !== undefined && state.life !== null;
+            return this.impl.hasLife();
         }
 
         /**
@@ -763,9 +947,9 @@ namespace info {
         //% group="Multiplayer"
         //% blockId=playerinfoonlifezero block="on %player life zero"
         //% help=info/on-life-zero
+        //% parts="multiplayer"
         onLifeZero(handler: () => void) {
-            const state = this.getState();
-            state.lifeZeroHandler = handler;
+            this.impl.onLifeZero(handler);
         }
 
         /**
@@ -781,21 +965,9 @@ namespace info {
         //% score.defl=100
         //% help=info/on-score
         //% group="Multiplayer"
+        //% parts="multiplayer"
         onScore(score: number, handler: () => void) {
-            const state = this.getState();
-            state.scoreReachedHandler = new ScoreReachedHandler(score, handler);
-        }
-
-        raiseLifeZero(gameOver: boolean) {
-            const state = this.getState();
-            if (state.life !== null && state.life <= 0) {
-                state.life = null;
-                if (state.lifeZeroHandler) {
-                    state.lifeZeroHandler();
-                } else if (gameOver) {
-                    game.over();
-                }
-            }
+            this.impl.onScore(score, handler);
         }
 
         drawPlayer() {
@@ -809,8 +981,8 @@ namespace info {
             let lifeWidth = 0;
             const offsetX = 1;
             let offsetY = 2;
-            let showScore = this.showScore && state.score !== undefined;
-            let showLife = this.showLife && state.life !== undefined;
+            let showScore = this.impl.showScore && state.score !== undefined;
+            let showLife = this.impl.showLife && state.life !== undefined;
 
             if (showScore) {
                 score = "" + state.score;
@@ -830,27 +1002,27 @@ namespace info {
             // bump size for space between lines
             if (showScore && showLife) height++;
 
-            const x = this.x - (this.left ? width : 0);
-            const y = this.y - (this.up ? height : 0);
+            const x = this.impl.x - (this.impl.left ? width : 0);
+            const y = this.impl.y - (this.impl.up ? height : 0);
 
             // Bordered Box
             if (showScore || showLife) {
-                screen.fillRect(x, y, width, height, this.border);
-                screen.fillRect(x + 1, y + 1, width - 2, height - 2, this.bg);
+                screen.fillRect(x, y, width, height, this.impl.border);
+                screen.fillRect(x + 1, y + 1, width - 2, height - 2, this.impl.bg);
             }
 
             // print score
             if (showScore) {
-                const bump = this.left ? width - scoreWidth : 0;
-                screen.print(score, x + offsetX + bump + 1, y + 2, this.fc, font);
+                const bump = this.impl.left ? width - scoreWidth : 0;
+                screen.print(score, x + offsetX + bump + 1, y + 2, this.impl.fc, font);
             }
 
             // print life
             if (showLife) {
-                const xLoc = x + offsetX + (this.left ? width - lifeWidth : 0);
+                const xLoc = x + offsetX + (this.impl.left ? width - lifeWidth : 0);
 
                 let mult = infoState.multiplierImage.clone();
-                mult.replace(1, this.fc);
+                mult.replace(1, this.impl.fc);
 
                 screen.drawTransparentImage(
                     infoState.heartImage,
@@ -866,24 +1038,24 @@ namespace info {
                     life,
                     xLoc + infoState.heartImage.width + infoState.multiplierImage.width + 1,
                     y + offsetY,
-                    this.fc,
+                    this.impl.fc,
                     font
                 );
             }
 
             // print player icon
-            if (this.showPlayer) {
+            if (this.impl.showPlayer) {
                 const pNum = "" + this._player;
 
                 let iconWidth = pNum.length * font.charWidth + 1;
                 const iconHeight = Math.max(height, font.charHeight + 2);
-                let iconX = this.left ? (x - iconWidth + 1) : (x + width - 1);
+                let iconX = this.impl.left ? (x - iconWidth + 1) : (x + width - 1);
                 let iconY = y;
 
                 // adjustments when only player icon shown
                 if (!showScore && !showLife) {
-                    iconX += this.left ? -1 : 1;
-                    if (this.up) iconY -= 3;
+                    iconX += this.impl.left ? -1 : 1;
+                    if (this.impl.up) iconY -= 3;
                 }
 
                 screen.fillRect(
@@ -891,20 +1063,20 @@ namespace info {
                     iconY,
                     iconWidth,
                     iconHeight,
-                    this.border
+                    this.impl.border
                 );
                 screen.print(
                     pNum,
                     iconX + 1,
                     iconY + (iconHeight >> 1) - (font.charHeight >> 1),
-                    this.bg,
+                    this.impl.bg,
                     font
                 );
             }
         }
 
         drawScore() {
-            const s = this.score() | 0;
+            const s = this.impl.score() | 0;
 
             let font: image.Font;
             let offsetY: number;