pxt-common-packages 10.3.8 → 10.3.9

package/libs/game/game.ts

@@ -1,18 +1,102 @@
 /**
  * Game transitions and dialog
  **/
-//% color=#8854d0 weight=97 icon="\uf111"
-//% groups='["Gameplay", "Prompt"]'
 namespace game {
     /**
      * Determines if diagnostics are shown
      */
     export let debug = false;
     export let stats = false;
-    export let winEffect: effects.BackgroundEffect = undefined;
-    export let loseEffect: effects.BackgroundEffect = undefined;
-    let loseSound: music.Melody = undefined;
-    let winSound: music.Melody = undefined;
+
+    export enum ScoringType {
+        //% block="high score"
+        HighScore,
+        //% block="low score"
+        LowScore,
+        //% block="none"
+        None
+    }
+
+    export class GameOverConfig {
+        scoringType: ScoringType;
+        winEffect: effects.BackgroundEffect;
+        loseEffect: effects.BackgroundEffect;
+        loseSound: music.Melody;
+        winSound: music.Melody;
+        winMessage: string;
+        winMessageMultiplayer: string;
+        loseMessage: string;
+        effectSetByUser: boolean;
+        soundSetByUser: boolean;
+        messageSetByUser: boolean;
+        scoringTypeSetByUser: boolean;
+
+        constructor() {
+            this.init();
+        }
+
+        init() {
+            this.scoringType = ScoringType.HighScore;
+            this.winEffect = effects.confetti;
+            this.loseEffect = effects.melt;
+            this.winSound = music.powerUp;
+            this.loseSound = music.wawawawaa;
+            this.winMessage = "YOU WIN!";
+            this.winMessageMultiplayer = "${WINNER} WINS!";
+            this.loseMessage = "GAME OVER";
+            this.effectSetByUser = false;
+            this.soundSetByUser = false;
+            this.messageSetByUser = false;
+            this.scoringTypeSetByUser = false;
+        }
+
+        setScoringType(type: ScoringType, explicit?: boolean) {
+            if (!explicit && this.scoringTypeSetByUser) return;
+            this.scoringType = type;
+            if (explicit) this.scoringTypeSetByUser = true;
+        }
+
+        setEffect(win: boolean, effect: effects.BackgroundEffect, explicit?: boolean) {
+            if (!explicit && this.effectSetByUser) return;
+            if (win) this.winEffect = effect;
+            else this.loseEffect = effect;
+            if (explicit) this.effectSetByUser = true;
+        }
+        getEffect(win: boolean) {
+            return win ? this.winEffect : this.loseEffect;
+        }
+
+        setSound(win: boolean, sound: music.Melody, explicit?: boolean) {
+            if (!explicit && this.soundSetByUser) return;
+            if (win) this.winSound = sound;
+            else this.loseSound = sound;
+            if (explicit) this.soundSetByUser = true;
+        }
+        getSound(win: boolean) {
+            return win ? this.winSound : this.loseSound;
+        }
+
+        setMessage(win: boolean, message: string, explicit?: boolean) {
+            if (!explicit && this.messageSetByUser) return;
+            if (win) this.winMessage = message;
+            else this.loseMessage = message;
+            if (explicit) this.messageSetByUser = true;
+        }
+        getMessage(win: boolean, preferMultiplayer?: boolean) {
+            if (this.messageSetByUser)
+                return win ? this.winMessage : this.loseMessage;
+            else if (preferMultiplayer)
+                return win ? this.winMessageMultiplayer : this.loseMessage;
+            else
+                return win ? this.winMessage : this.loseMessage;
+        }
+    }
+
+    let _gameOverConfig: GameOverConfig;
+    export const gameOverConfig = () => {
+        if (!_gameOverConfig) _gameOverConfig = new GameOverConfig();
+        return _gameOverConfig;
+    }
 
     let _scene: scene.Scene;
     let _sceneStack: scene.Scene[];
@@ -48,16 +132,6 @@ namespace game {
             _scene = new scene.Scene(control.pushEventContext(), _scene);
         }
         _scene.init();
-
-        if (!winEffect)
-            winEffect = effects.confetti;
-        if (!loseEffect)
-            loseEffect = effects.melt;
-
-        if (!winSound)
-            winSound = music.powerUp;
-        if (!loseSound)
-            loseSound = music.wawawawaa;
     }
 
     export function pushScene() {
@@ -139,31 +213,81 @@ namespace game {
 
     /**
      * Set the effect that occurs when the game is over
-     * @param win whether the animation should run on a win (true)
+     * @param win whether the effect should run on a win (true) or lose (false)
      * @param effect
      */
+    //% blockId=game_setgameovereffect
+    //% block="use effect $effect for $win"
+    //% effect.defl=effects.confetti
+    //% win.shadow=toggleWinLose
+    //% win.defl=true
+    //% group="Game Over"
+    //% weight=80
+    //% blockGap=8
+    //% help=game/set-game-over-effect
     export function setGameOverEffect(win: boolean, effect: effects.BackgroundEffect) {
         init();
-        if (!effect) return;
-        if (win)
-            winEffect = effect;
-        else
-            loseEffect = effect;
+        const goc = game.gameOverConfig();
+        goc.setEffect(win, effect, true);
     }
 
     /**
-     * Set the music that occurs when the player wins
-     * @param win
+     * Set the music that occurs when the game is over
+     * @param win whether the sound should play on a win (true) or lose (false)
      * @param effect
      */
+    //% blockId=game_setgameoversound
+    //% block="use sound $sound for $win"
+    //% sound.defl=music.powerUp
+    //% win.shadow=toggleWinLose
+    //% win.defl=true
+    //% group="Game Over"
+    //% weight=80
+    //% blockGap=8
+    //% help=game/set-game-over-sound
     export function setGameOverSound(win: boolean, sound: music.Melody) {
         init();
-        if (!sound) return;
-        if (win)
-            winSound = sound;
-        else
-            loseSound = sound;
+        const goc = game.gameOverConfig();
+        goc.setSound(win, sound, true);
     }
+
+    /**
+     * Set the message that displays when the game is over
+     * @param win whether the message should show on a win (true) or lose (false)
+     * @param message 
+     */
+    //% blockId=game_setgameovermessage
+    //% block="use message $message for $win"
+    //% message.defl="GAME OVER!"
+    //% win.shadow=toggleWinLose
+    //% win.defl=true
+    //% group="Game Over"
+    //% weight=80
+    //% blockGap=8
+    //% help=game/set-game-over-message
+    export function setGameOverMessage(win: boolean, message: string) {
+        init();
+        const goc = game.gameOverConfig();
+        goc.setMessage(win, message, true);
+    }
+
+    /**
+     * Set the method of judging the best score for the game
+     * @param type the scoring type
+     */
+    //% blockId=game_setgameoverscoringtype
+    //% block="use $type as best score"
+    //% type.defl=ScoringType.HighScore
+    //% group="Game Over"
+    //% weight=80
+    //% blockGap=8
+    //% help=game/set-game-over-scoring-type
+    export function setGameOverScoringType(type: ScoringType) {
+        init();
+        const goc = game.gameOverConfig();
+        goc.setScoringType(type, true);
+    }
+
     /**
      * Set the function to call on game over. The 'win' boolean is
      * passed to the handler.
@@ -179,7 +303,30 @@ namespace game {
     //% group="Gameplay"
     //% blockId=gameOver block="game over %win=toggleWinLose || with %effect effect"
     //% weight=80 help=game/over
+    //% deprecated=true
     export function over(win: boolean = false, effect?: effects.BackgroundEffect) {
+        // Match legacy behavior unless effect was set by user
+        const goc = game.gameOverConfig();
+        goc.setEffect(win, effect, false);
+        _gameOverImpl(win);
+    }
+
+    //% blockId=gameOver2 block="game over $win"
+    //% win.shadow=toggleWinLose
+    //% win.defl=true
+    //% weight=80
+    //% blockGap=8
+    //% help=game/over
+    //% group="Game Over"
+    export function gameOver(win: boolean) {
+        _gameOverImpl(win);
+    }
+
+    export function gameOverPlayerWin(player: number) {
+        _gameOverImpl(true, player);
+    }
+
+    function _gameOverImpl(win: boolean, winnerOverride?: number) {
         init();
         if (__isOver) return;
         __isOver = true;
@@ -187,18 +334,24 @@ namespace game {
         if (__gameOverHandler) {
             __gameOverHandler(win);
         } else {
-            if (!effect) {
-                effect = win ? winEffect : loseEffect;
-            }
+            const goc = game.gameOverConfig();
 
-            // Save all scores as relevant to the game.
-            info.saveAllScores();
+            const judged = !winnerOverride && goc.scoringType !== ScoringType.None;
+            const playersWithScores = info.playersWithScores();
+            const prevBestScore = judged && info.highScore();
+            const winner = judged && win && info.winningPlayer();
+            const scores = playersWithScores.map(player => new GameOverPlayerScore(player.number, player.impl.score(), player === winner));
 
-            // collect the scores before poping the scenes
-            const scoreInfo = info.player1.getState();
-            const highScore = info.highScore();
-            if (scoreInfo.score > highScore)
+            // Save scores if this was a judged game and there was a winner (don't save in the LOSE case).
+            if (judged && winner) {
+                info.saveAllScores();
                 info.saveHighScore();
+            }
+
+            const preferMultiplayer = !!winnerOverride || (judged && info.multiplayerScoring());
+            const message = goc.getMessage(win, preferMultiplayer);
+            const effect = goc.getEffect(win);
+            const sound = goc.getSound(win);
 
             // releasing memory and clear fibers. Do not add anything that releases the fiber until background is set below,
             // or screen will be cleared on the new frame and will not appear as background in the game over screen.
@@ -209,16 +362,12 @@ namespace game {
             pushScene();
             scene.setBackgroundImage(screen.clone());
 
-            if (win)
-                winSound.play();
-            else
-                loseSound.play();
-
-            effect.startScreenEffect();
+            if (sound) sound.play();
+            if (effect) effect.startScreenEffect();
 
             pause(400);
 
-            const overDialog = new GameOverDialog(win, scoreInfo.score, highScore);
+            const overDialog = new GameOverDialog(win, message, judged, scores, prevBestScore, winnerOverride);
             scene.createRenderable(scene.HUD_Z, target => {
                 overDialog.update();
                 target.drawTransparentImage(

package/libs/game/gameutil.ts

@@ -1,8 +1,6 @@
 /**
  * Game transitions and dialog
  **/
-//% color=#8854d0 weight=97 icon="\uf111"
-//% groups='["Gameplay", "Prompt"]'
 namespace game {
 
     /**

package/libs/game/info.ts

@@ -35,7 +35,17 @@ namespace info {
         public lifeZeroHandler: () => void;
         public scoreReachedHandler: ScoreReachedHandler
 
-        constructor() { }
+        public showScore?: boolean;
+        public showLife?: boolean;
+        public visibility: Visibility;
+        public showPlayer?: boolean;
+
+        constructor() {
+            this.visibility = Visibility.None;
+            this.showScore = undefined;
+            this.showLife = undefined;
+            this.showPlayer = undefined;
+        }
     }
 
     class InfoState {
@@ -148,7 +158,11 @@ namespace info {
                             if (infoState.countdownEndHandler) {
                                 infoState.countdownEndHandler();
                             } else {
-                                game.over();
+                                // Clear effect and sound, unless set by user
+                                const goc = game.gameOverConfig();
+                                goc.setEffect(false, null, false);
+                                goc.setSound(false, null, false);
+                                game.gameOver(false);
                             }
                         }
                     }
@@ -212,11 +226,26 @@ namespace info {
                 `;
     }
 
+    export function multiplayerScoring() {
+        const pws = playersWithScores();
+        for (const p of pws) {
+            if (p.number > 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    export function playersWithScores(): PlayerInfo[] {
+        return players ? players.filter(item => item.impl.hasScore()) : [];
+    }
+
     export function saveAllScores() {
         const allScoresKey = "all-scores";
         let allScores: number[];
-        if (players) {
-            allScores = players.filter(item => item.impl.hasScore()).map(item => item.impl.score());
+        const pws = playersWithScores();
+        if (pws) {
+            allScores = pws.map(item => item.impl.score());
         }
         else {
             allScores = [];
@@ -225,15 +254,44 @@ namespace info {
         settings.writeJSON(allScoresKey, allScores);
     }
 
+    export function winningPlayer(): PlayerInfo {
+        let winner: PlayerInfo = null;
+        const pws = playersWithScores();
+        if (pws) {
+            const goc = game.gameOverConfig();
+            let hs: number = null;
+            pws.forEach(p => {
+                const s = p.impl.score();
+                if (isBetterScore(s, hs)) {
+                    hs = s;
+                    winner = p;
+                }
+            });
+        }
+        return winner;
+    }
+
+    export function isBetterScore(newScore: number, prevScore: number): boolean {
+        const goc = game.gameOverConfig();
+        switch (goc.scoringType) {
+            case game.ScoringType.HighScore: {
+                return prevScore == null || newScore > prevScore;
+            }
+            case game.ScoringType.LowScore: {
+                return prevScore == null || newScore < prevScore;
+            }
+        }
+        return false;
+    }
+
     export function saveHighScore() {
-        if (players) {
-            let hs = 0;
-            players
-                .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)
+        const winner = winningPlayer();
+        if (winner) {
+            let hs = winner.impl.score();
+            let curr = settings.readNumber("high-score");
+            if (isBetterScore(hs, curr)) {
                 settings.writeNumber("high-score", hs);
+            }
         }
     }
 
@@ -576,10 +634,6 @@ namespace info {
         public bg: number; // background color
         public border: number; // border color
         public fc: number; // font color
-        public showScore?: boolean;
-        public showLife?: boolean;
-        public visibility: Visibility;
-        public showPlayer?: boolean;
         public x?: number;
         public y?: number;
         public left?: boolean; // if true banner goes from x to the left, else goes rightward
@@ -589,10 +643,6 @@ namespace info {
             this._player = player;
             this.border = 1;
             this.fc = 1;
-            this.visibility = Visibility.None;
-            this.showScore = undefined;
-            this.showLife = undefined;
-            this.showPlayer = undefined;
             this.left = undefined;
             this.up = undefined;
             if (this._player === 1) {
@@ -640,11 +690,11 @@ namespace info {
         }
 
         score(): number {
-            if (this.showScore === undefined) this.showScore = true;
-            if (this.showPlayer === undefined) this.showPlayer = true;
-
             const state = this.getState();
 
+            if (state.showScore === undefined) state.showScore = true;
+            if (state.showPlayer === undefined) state.showPlayer = true;
+
             if (state.score == null)
                 state.score = 0;
             return state.score;
@@ -680,8 +730,9 @@ namespace info {
 
         life(): number {
             const state = this.getState();
-            if (this.showLife === undefined) this.showLife = true;
-            if (this.showPlayer === undefined) this.showPlayer = true;
+
+            if (state.showLife === undefined) state.showLife = true;
+            if (state.showPlayer === undefined) state.showPlayer = true;
 
             if (state.life === undefined) {
                 state.life = 3;
@@ -725,7 +776,11 @@ namespace info {
                 if (state.lifeZeroHandler) {
                     state.lifeZeroHandler();
                 } else if (gameOver) {
-                    game.over();
+                    // Clear effect and sound, unless set by user
+                    const goc = game.gameOverConfig();
+                    goc.setEffect(false, null, false);
+                    goc.setSound(false, null, false);
+                    game.gameOver(false);
                 }
             }
         }
@@ -753,6 +808,13 @@ namespace info {
             }
         }
 
+        /**
+         * Returns the one-based number of the player
+         */
+        get number() {
+            return this._player;
+        }
+
         get bg(): number {
             return this.impl.bg;
         }
@@ -778,35 +840,35 @@ namespace info {
         }
 
         get showScore(): boolean {
-            return this.impl.showScore;
+            return this.impl.getState().showScore;
         }
 
         set showScore(value: boolean) {
-            this.impl.showScore = value;
+            this.impl.getState().showScore = value;
         }
 
         get showLife(): boolean {
-            return this.impl.showLife;
+            return this.impl.getState().showLife;
         }
 
         set showLife(value: boolean) {
-            this.impl.showLife = value;
+            this.impl.getState().showLife = value;
         }
 
         get visibility(): Visibility {
-            return this.impl.visibility;
+            return this.impl.getState().visibility;
         }
 
         set visibility(value: Visibility) {
-            this.impl.visibility = value;
+            this.impl.getState().visibility = value;
         }
 
         get showPlayer(): boolean {
-            return this.impl.showPlayer;
+            return this.impl.getState().showPlayer;
         }
 
         set showPlayer(value: boolean) {
-            this.impl.showPlayer = value;
+            this.impl.getState().showPlayer = value;
         }
 
         get x(): number {
@@ -981,8 +1043,8 @@ namespace info {
             let lifeWidth = 0;
             const offsetX = 1;
             let offsetY = 2;
-            let showScore = this.impl.showScore && state.score !== undefined;
-            let showLife = this.impl.showLife && state.life !== undefined;
+            let showScore = state.showScore && state.score !== undefined;
+            let showLife = state.showLife && state.life !== undefined;
 
             if (showScore) {
                 score = "" + state.score;
@@ -1044,7 +1106,7 @@ namespace info {
             }
 
             // print player icon
-            if (this.impl.showPlayer) {
+            if (state.showPlayer) {
                 const pNum = "" + this._player;
 
                 let iconWidth = pNum.length * font.charWidth + 1;

package/libs/game/ns.ts

@@ -0,0 +1,5 @@
+//% color=#8854d0 weight=97 icon="\uf111"
+//% blockGap=8
+//% groups='["Gameplay", "Game Over", "Prompt",  "Dialogs"]'
+namespace game {
+}

package/libs/game/numberprompt.ts

@@ -5,7 +5,6 @@ namespace game {
      * @param message The message to display on the text-entry screen
      * @param answerLength The maximum number of digits the user can enter (1 - 10)
      */
-    //% group="Gameplay"
     //% weight=10 help=game/ask-for-number
     //% blockId=gameaskfornumber block="ask for number %message || and max length %answerLength"
     //% message.shadow=text

package/libs/game/particleeffects.ts

@@ -337,4 +337,34 @@ namespace effects {
         source.z = -2;
         return source;
     });
+
+    //% fixedInstance whenUsed block="none"
+    export const none = new ScreenEffect(0, 0, 0, function (anchor: particles.ParticleAnchor, particlesPerSecond: number) {
+        class NullParticleSource extends particles.ParticleSource {
+            constructor() {
+                super(null, 0);
+                this._prune();
+            }
+
+            __draw(camera: scene.Camera) {}
+
+            _update(dt: number) {}
+
+            // remove self at next opportunity
+            _prune() {
+                const scene = game.currentScene();
+                if (!scene)
+                    return;
+                scene.allSprites.removeElement(this);
+                const sources = scene.particleSources;
+                if (sources && sources.length)
+                    sources.removeElement(this);
+            }
+            destroy() { this._prune(); }
+            clear() { this.head = undefined; }
+        }
+        const source = new NullParticleSource();
+
+        return source;
+    });
 }

package/libs/game/prompt.ts

@@ -16,7 +16,6 @@ namespace game {
      * @param message The message to display on the text-entry screen
      * @param answerLength The maximum number of characters the user can enter (1 - 24)
      */
-    //% group="Gameplay"
     //% weight=10 help=game/ask-for-string
     //% blockId=gameaskforstring block="ask for string %message || and max length %answerLength"
     //% message.shadow=text

package/libs/game/pxt.json

@@ -2,6 +2,7 @@
     "name": "game",
     "description": "The game and sprite library - beta",
     "files": [
+        "ns.ts",
         "gameoverrides.ts",
         "basesprite.ts",
         "constants.ts",