Update Basketball game

demos/basketball/src/core/game.js

             this.spawn(TutorialOverlay),
             this.spawn(GameOverOverlay),
 
-        ]);
+        ]).then(() => void 0);
     }
 
     /**

demos/basketball/src/core/globals.js

 export const NUMBER_OF_BALLS = 5;
 
 /** The minimum score for each rank */
-export const SCORE_TABLE = Object.freeze({
+export const RANK_TABLE = Object.freeze({
     'S':  15,
     'A+': 12,
     'A':  11,

demos/basketball/src/entities/ball.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
 
         this._state = 'ready';
         this._runState = {
      */
     async init()
     {
-        const file = this._demo.assetManager.file('ball.glb');
+        const file = this._game.assetManager.file('ball.glb');
         const gltf = await BABYLON.SceneLoader.ImportMeshAsync('', '', file);
         const mesh = this._createPhysicsRoot(gltf.meshes[0]); // gltf.meshes[0] is __root__
 

demos/basketball/src/entities/entity.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        this._demo = demo;
+        this._game = game;
     }
 
     /**
      */
     _broadcast(event)
     {
-        this._demo.broadcast(event);
+        this._game.broadcast(event);
     }
 
     /**
      */
     get ar()
     {
-        return this._demo.ar;
+        return this._game.ar;
     }
 }
 
 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._physicsAnchor = null;
     }
 

demos/basketball/src/entities/game-controller.js

 
 import { Entity } from './entity.js';
 import { GameEvent } from '../core/events.js';
-import { NUMBER_OF_BALLS, SCORE_TABLE } from '../core/globals.js';
+import { NUMBER_OF_BALLS, RANK_TABLE } from '../core/globals.js';
 
 /**
  * The Game Controller manages the state of the game
 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
 
         this._ballsLeft = NUMBER_OF_BALLS;
         this._score = 0;
      */
     _computeRank(score)
     {
-        const entries = Object.entries(SCORE_TABLE).sort((a, b) => b[1] - a[1]);
+        const entries = Object.entries(RANK_TABLE).sort((a, b) => b[1] - a[1]);
 
         for(const [rank, minScore] of entries) {
             if(score >= minScore)

demos/basketball/src/entities/goal.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._physicsRoot = null;
     }
 
      */
     async init()
     {
-        const file = this._demo.assetManager.file('goal.glb');
+        const file = this._game.assetManager.file('goal.glb');
         const gltf = await BABYLON.SceneLoader.ImportMeshAsync('', '', file);
         this._physicsRoot = this._createPhysicsRoot(gltf.meshes);
         this._physicsRoot.position.y = Y_OFFSET;

demos/basketball/src/entities/gravity.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._gravity = new BABYLON.Vector3();
         this._isTracking = false;
     }

demos/basketball/src/entities/gui/ball-counter.js

      */
     _createControl()
     {
-        const url = this._demo.assetManager.url('atlas.png');
+        const url = this._game.assetManager.url('atlas.png');
         const icon = new BABYLON.GUI.Image('ballIcon', url);
 
         icon.sourceLeft = 896;
         const icons = [];
 
         for(let i = 0; i < NUMBER_OF_BALLS; i++) {
-            const icon = this._demo.spawn(BallIcon).then(icon => icon.setId(i));
+            const icon = this._game.spawn(BallIcon).then(icon => icon.setId(i));
             icons.push(icon);
         }
 
-        return Promise.all(icons);
+        return Promise.all(icons).then(() => void 0);
     }
 }

demos/basketball/src/entities/gui/gameover-overlay.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
 
         this._messages = {
             'S' : 'YOU ARE A\nLEGEND!!!!!',

demos/basketball/src/entities/gui/gui-control.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._parent = demo.gui;
         this._control = null;
     }

demos/basketball/src/entities/gui/mute-button.js

      */
     _createControl()
     {
-        const url = this._demo.assetManager.url('atlas.png');
+        const url = this._game.assetManager.url('atlas.png');
         const button = BABYLON.GUI.Button.CreateImageOnlyButton('muteButton', url);
         const offset = 1.5 + ((NUMBER_OF_BALLS / 2) | 0);
 

demos/basketball/src/entities/gui/tutorial-overlay.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._timer = 0;
         this._enabled = true;
     }
      */
     _createControl()
     {
-        const url = this._demo.assetManager.url('atlas.png');
+        const url = this._game.assetManager.url('atlas.png');
         const container = new BABYLON.GUI.Container();
         const text = new BABYLON.GUI.TextBlock();
         const hand = new BABYLON.GUI.Image('hand', url);

demos/basketball/src/entities/jukebox.js

 {
      /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._sound = new Map();
     }
 
         const soundFiles = ASSET_LIST.filter(asset => asset.endsWith('.wav'));
 
         for(const filepath of soundFiles) {
-            const url = this._demo.assetManager.url(filepath);
+            const url = this._game.assetManager.url(filepath);
             const soundName = filepath.substring(0, filepath.length - 4);
             const sound = new BABYLON.Sound(soundName, url);
 

demos/basketball/src/entities/net.js

 {
     /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
 
         this._physicsRoot = null;
         this._mesh = null;
     _createMaterial()
     {
         const material = new BABYLON.StandardMaterial('BasketballNetMaterial');
-        const url = this._demo.assetManager.url('atlas.png');
+        const url = this._game.assetManager.url('atlas.png');
 
         material.diffuseTexture = new BABYLON.Texture(url);
         material.diffuseTexture.hasAlpha = true;

demos/basketball/src/entities/score-text.js

 {
      /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._score = 0;
         this._mesh = null;
         this._initialPosition = new BABYLON.Vector3();
             height: 0.5,
         });
 
-        const url = this._demo.assetManager.url('atlas.png');
+        const url = this._game.assetManager.url('atlas.png');
         const material = new BABYLON.StandardMaterial('ScoreTextMaterial');
 
         material.diffuseTexture = new BABYLON.Texture(url);

demos/basketball/src/entities/scoreboard.js

 {
      /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._mesh = null;
     }
 
             height: 1.0,
         });
 
-        const url = this._demo.assetManager.url('atlas.png');
+        const url = this._game.assetManager.url('atlas.png');
         const material = new BABYLON.StandardMaterial('ScoreboardDigitMaterial');
 
         material.diffuseTexture = new BABYLON.Texture(url);
 {
      /**
      * Constructor
-     * @param {BasketballDemo} demo
+     * @param {BasketballGame} game
      */
-    constructor(demo)
+    constructor(game)
     {
-        super(demo);
+        super(game);
         this._mesh = null;
         this._units = null;
         this._tens = null;
         this._mesh.material = new BABYLON.StandardMaterial('ScoreboardMaterial');
         this._mesh.material.diffuseColor = BABYLON.Color3.FromHexString('#110d7c');
 
-        this._units = await this._demo.spawn(ScoreboardDigit);
+        this._units = await this._game.spawn(ScoreboardDigit);
         this._units.mesh.position = new BABYLON.Vector3(x, y, z);
         this._units.mesh.parent = this._mesh;
 
-        this._tens = await this._demo.spawn(ScoreboardDigit);
+        this._tens = await this._game.spawn(ScoreboardDigit);
         this._tens.mesh.position = new BABYLON.Vector3(-x, y, z);
         this._tens.mesh.parent = this._mesh;