brick-engine-cli 1.0.8 → 1.0.10

package/dist/index.js

@@ -12,7 +12,7 @@ function run() {
     commander_1.program
         .name("brick-engine-cli")
         .description("CLI to scaffold Brick Engine projects")
-        .version("1.0.0");
+        .version("1.0.8");
     commander_1.program
         .command("init <name>")
         .description("Initialize a new Brick Engine project")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brick-engine-cli",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "CLI to scaffold Brick Game projects",
   "main": "dist/index.js",
   "bin": {
@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "@types/inquirer": "^8.2.12",
-    "brick-engine-js": "^1.0.20",
+    "brick-engine-js": "^1.0.22",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
     "dotenv": "^17.3.1",

package/src/index.ts

@@ -2,12 +2,13 @@ import { program } from "commander";
 import { initCommand } from "./commands/init";
 import { publishCommand } from "./commands/publish";
 import chalk from "chalk";
+import { readFileSync } from "fs";
 
 export function run() {
   program
     .name("brick-engine-cli")
     .description("CLI to scaffold Brick Engine projects")
-    .version("1.0.0");
+    .version("1.0.8");
 
   program
     .command("init <name>")

package/templates/src/index.ts

@@ -1,100 +1,169 @@
-import { Game, FontSize, ControlKey, ControlEventType, Sound, FontAlign, FontVerticalAlign, Color } from 'brick-engine-js';
+import { Game, FontSize, ControlKey, ControlEventType, Sound, FontAlign, FontVerticalAlign, Color, Coordinate, StateProperty } from 'brick-engine-js';
 
 export default class MyGame extends Game {
-    y = 0;
-    x = 5;
+    private playerX = 5;
+    private enemies: Coordinate[] = [];
+    private spawnRate = 5; // Ticks between spawns
+    private initTickInterval = 200;
 
     /**
      * Called once after the engine and its modules are fully initialized.
-     * Ideal for setting initial state, text sizes, and subscribing to controls.
      */
     setupGame(): void {
-        const { grid, control, sound } = this.modules;
-
-        // Example: Subscriber to ACTION button
-        control.subscribeForPlayingScreen(ControlKey.ACTION, ControlEventType.PRESSED, () => {
-            sound.play(Sound.ACTION_1);
-            grid.stampCell({
-                coordinate: { x: this.x, y: this.y },
-                color: Color.CYAN,
-                value: 1,
-            });
-            this.modules.time.decrementTickInterval(this.y);
-            this.y++;
-        });
-
-        this.modules.session.register({
-            serialId: 'coords',
-            deserialize: data => {
-                const { x, y } = JSON.parse(data);
-                this.x = x;
-                this.y = y;
+        const { control, session } = this.modules;
+
+        // Register how game data should be serialized and deserialized for the session
+        session.register({
+            // Unique identifier for the session data
+            serialId: 'game-data',
+            // Recieves from LocalStorage and restore the game state
+            deserialize: (data: string) => {
+                if (!data) return;
+                const { playerX, enemies } = JSON.parse(data);
+                this.playerX = playerX;
+                this.enemies = enemies;
             },
+            // Prepare data to be saved to LocalStorage
             serialize: () => {
-                return JSON.stringify({ x: this.x, y: this.y });
+                return JSON.stringify({
+                    playerX: this.playerX,
+                    enemies: this.enemies,
+                });
             },
         });
+
+        this.onStart();
+
+        // Move Left
+        control.subscribeForPlayingScreen(ControlKey.LEFT, ControlEventType.PRESSED, () => {
+            this.movePlayer(-1);
+        });
+
+        // Move Right
+        control.subscribeForPlayingScreen(ControlKey.RIGHT, ControlEventType.PRESSED, () => {
+            this.movePlayer(1);
+        });
+    }
+
+    private movePlayer(dx: number): void {
+        const { grid, sound } = this.modules;
+
+        const newX = this.playerX + dx;
+
+        if (grid.isCoordinateValid({ x: newX, y: grid.bottomRow })) {
+            this.playerX = newX;
+            sound.play(Sound.KEY_PRESS);
+        }
     }
 
     /**
-     * Called on every logic "tick". The frequency is defined by the game's tickInterval.
-     * This is where movement, collision, and state updates should happen.
-     * Logic here ONLY runs when the game is in the PLAYING state.
+     * Logic update on every game "tick".
      */
-    update(deltaTime: number): void {
-        const actualCoordinate = { x: this.x, y: this.y };
+    update(): void {
+        const { grid, state, score, sound, time } = this.modules;
+
+        // 1. Move enemies down
+        this.enemies = this.enemies.map(enemy => ({ x: enemy.x, y: enemy.y + 1 })).filter(enemy => grid.isCoordinateValid({ x: enemy.x, y: enemy.y }));
 
-        if (!this.modules.grid.isValidCoordinate(actualCoordinate)) {
-            this.modules.state.triggerGameOver();
+        // 2. Spawn new enemy
+        if (time.isTickEvery(this.spawnRate)) {
+            const spawnX = Math.floor(Math.random() * grid.width);
+            this.enemies.push({ x: spawnX, y: grid.topRow });
         }
 
-        this.modules.score.increaseScore(1);
+        // 3. Check collisions
+        const playerY = grid.bottomRow;
+        const collision = this.enemies.find(enemy => enemy.x === this.playerX && enemy.y === playerY);
+
+        if (collision) {
+            sound.play(Sound.EXPLOSION);
+            state.triggerGameOver();
+            return;
+        }
+
+        // 4. Update Grid
+        grid.resetGrid();
+
+        // Draw Player
+        grid.stampCell({
+            coordinate: { x: this.playerX, y: playerY },
+            color: Color.CYAN,
+            value: 1,
+        });
+
+        // Draw Enemies
+        this.enemies.forEach(enemy => {
+            grid.stampCell({
+                coordinate: enemy,
+                color: Color.RED,
+                value: 2,
+            });
+        });
+
+        // 5. Increase score and difficulty
+        score.increaseScore(1);
+
+        // Increase speed every 50 points
+        if (score.score > 0 && score.score % 50 === 0 && score.level < score.maxLevel) {
+            time.setTickInterval(this.initTickInterval - 15 * score.level);
+
+            score.increaseLevel(1);
+
+            if (score.level < 6) {
+                sound.play(Sound.SCORE_2);
+            } else {
+                sound.play(Sound.SCORE_3);
+            }
+        }
     }
 
     /**
-     * Called every rendering frame (60fps).
-     * Used for visual-only effects that don't impact game state (e.g. animations).
-     * Runs during PLAYING and PAUSED states.
+     * Visual-only rendering (HUD elements).
      */
-    render(): void {
-        const { text } = this.modules;
-
-        text.setTextSize(FontSize.EXTRA_SMALL);
-        text.setTextAlign(FontAlign.LEFT, FontVerticalAlign.TOP);
-        text.textOnDisplay('press', { x: 0.05, y: 0.05 });
-        text.textOnDisplay('action', { x: 0.05, y: 0.1 });
-    }
+    render(): void {}
 
     /**
-     * Rendered every frame when the device is ON but the game hasn't started.
-     * Usually displays the title and "Press Start" instructions.
+     * Title Screen Layout.
      */
     drawTitleScreen(): void {
         const { text } = this.modules;
 
         text.setTextSize(FontSize.MEDIUM);
         text.setTextAlign(FontAlign.CENTER, FontVerticalAlign.CENTER);
-        text.textOnDisplay('MY GAME', { x: 0.5, y: 0.2 });
+        text.textOnDisplay('DODGE BRICK', { x: 0.5, y: 0.3 });
 
         text.setTextSize(FontSize.SMALL);
-        text.textOnDisplay('running on', { x: 0.5, y: 0.48 });
-        text.textOnDisplay('drawTitleScreen', { x: 0.5, y: 0.55 });
+        text.textOnDisplay('USE ARROWS TO MOVE', { x: 0.5, y: 0.5 });
 
         text.setTextSize(FontSize.MEDIUM);
         text.textOnDisplay('PRESS START', { x: 0.5, y: 0.8 });
     }
 
     /**
-     * Rendered every frame when the game state reaches GAME OVER.
-     * Replaces standard `render()` calls to show scores or restart messages.
-     * Usually displays the game over message and "Press START to restart" instructions, and the final score.
+     * Game Over Screen Layout.
      */
     drawGameOverScreen(): void {
-        this.modules.text.setTextAlign(FontAlign.CENTER, FontVerticalAlign.CENTER);
+        const { text, score } = this.modules;
 
-        this.modules.text.textOnDisplay('GAME OVER', { x: 0.5, y: 0.5 });
+        text.setTextAlign(FontAlign.CENTER, FontVerticalAlign.CENTER);
+        text.setTextSize(FontSize.MEDIUM);
+        text.textOnDisplay('GAME OVER', { x: 0.5, y: 0.4 });
+
+        text.setTextSize(FontSize.SMALL);
+        text.textOnDisplay(`FINAL SCORE: ${score.score}`, { x: 0.5, y: 0.55 });
+
+        text.setTextSize(FontSize.MEDIUM);
+        text.textOnDisplay('PRESS START', { x: 0.5, y: 0.8 });
+    }
+
+    /**
+     * Reset game local state when starting/restarting.
+     */
+    onStart(): void {
+        const { score, time } = this.modules;
 
-        this.modules.text.setTextSize(FontSize.MEDIUM);
-        this.modules.text.textOnDisplay('PRESS START', { x: 0.5, y: 0.8 });
+        this.playerX = 5;
+        this.enemies = [];
+        time.setTickInterval(this.initTickInterval - 15 * score.level);
     }
 }