brick-engine-cli 1.0.1

package/src/commands/publish/index.ts

@@ -0,0 +1,201 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { execSync } from "child_process";
+import { SUPABASE_URL, SUPABASE_ANON_KEY } from "../../config/constants";
+
+export async function publishCommand(options: { url?: string; key?: string }) {
+  const currentDir = process.cwd();
+  const pkgPath = path.join(currentDir, "package.json");
+  const bundlePath = path.join(currentDir, "dist", "game.bundle.js");
+
+  console.log(
+    chalk.bold.blue("\n🧱 Brick Engine CLI") +
+      chalk.gray(" - Publishing your masterpiece\n"),
+  );
+
+  if (!fs.existsSync(pkgPath)) {
+    console.error(
+      chalk.red(
+        "✖ Error: No package.json found. Are you in a Brick Engine project directory?",
+      ),
+    );
+    process.exit(1);
+  }
+
+  // The bundle path will be checked after the build step now
+
+  // Resolve Supabase URL and Key
+  let supabaseUrl = options.url || process.env.SUPABASE_URL;
+  if (!supabaseUrl && SUPABASE_URL && !SUPABASE_URL.startsWith("%%")) {
+    supabaseUrl = SUPABASE_URL;
+  }
+
+  let supabaseAnonKey = options.key || process.env.SUPABASE_ANON_KEY;
+  if (
+    !supabaseAnonKey &&
+    SUPABASE_ANON_KEY &&
+    !SUPABASE_ANON_KEY.startsWith("%%")
+  ) {
+    supabaseAnonKey = SUPABASE_ANON_KEY;
+  }
+
+  const prompts = [];
+  if (!supabaseUrl) {
+    prompts.push({
+      type: "input",
+      name: "supabaseUrl",
+      message: "Enter your Supabase Project URL:",
+      validate: (input: string) =>
+        input.length > 0 ? true : "Supabase URL is required.",
+    });
+  }
+
+  if (!supabaseAnonKey) {
+    prompts.push({
+      type: "password",
+      name: "supabaseAnonKey",
+      message: "Enter your Supabase Anon Key:",
+      validate: (input: string) =>
+        input.length > 0 ? true : "Supabase Anon Key is required.",
+    });
+  }
+
+  prompts.push({
+    type: "input",
+    name: "gameName",
+    message: "Enter your game name:",
+  });
+
+  prompts.push({
+    type: "input",
+    name: "developerEmail",
+    message:
+      "Enter your developer email (to receive approval/rejection reasons):",
+  });
+
+  const pkg = await fs.readJson(pkgPath);
+  const gameId = pkg.name;
+  const version = pkg.version;
+
+  prompts.push({
+    type: "confirm",
+    name: "confirmPublish",
+    message: `Ready to publish ${chalk.cyan(gameId)} v${version}?`,
+    default: true,
+  });
+
+  const answers = await inquirer.prompt(prompts);
+  const gameName = answers.gameName;
+
+  if (!answers.confirmPublish) {
+    console.log(chalk.yellow("\nPublishing cancelled."));
+    return;
+  }
+
+  supabaseUrl = supabaseUrl || answers.supabaseUrl;
+  supabaseAnonKey = supabaseAnonKey || answers.supabaseAnonKey;
+  const developerEmail = pkg.author || answers.developerEmail;
+
+  console.log("");
+  console.log(
+    `${chalk.green("✔")} Preparing to publish ${chalk.cyan(gameName)} v${version}...`,
+  );
+
+  const formData = new FormData();
+  formData.append("game_id", gameId);
+  formData.append("game_name", gameName);
+  formData.append("version", version);
+  if (developerEmail) {
+    formData.append("developer_email", developerEmail);
+  }
+
+  console.log(chalk.gray("\n  Running build script..."));
+  try {
+    execSync("rm -rf dist && npm run build:bundle", {
+      stdio: "inherit",
+      cwd: currentDir,
+    });
+    console.log(`${chalk.green("✔")} Build completed successfully.\n`);
+  } catch (error) {
+    console.error(
+      chalk.red(
+        "\n✖ Error: Build failed. Please fix the errors in your project before publishing.",
+      ),
+    );
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(bundlePath)) {
+    console.error(
+      chalk.red(
+        "✖ Error: Game bundle not found. The build script did not generate 'dist/game.bundle.js'.",
+      ),
+    );
+    process.exit(1);
+  }
+
+  const bundleBuffer = await fs.readFile(bundlePath);
+  const bundleBlob = new Blob([bundleBuffer], {
+    type: "application/javascript",
+  });
+  formData.append("bundle", bundleBlob, "game.bundle.js");
+
+  const endpoint = `${supabaseUrl}/functions/v1/publish`;
+
+  try {
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${supabaseAnonKey}`,
+      },
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage = errorText;
+      try {
+        const errorJson = JSON.parse(errorText);
+        errorMessage = errorJson.error || errorJson.message || errorText;
+      } catch (e) {
+        // use raw text
+      }
+      throw new Error(
+        `Failed to publish: ${response.status} ${response.statusText}\n${errorMessage}`,
+      );
+    }
+
+    const result = await response.json();
+    console.log(`${chalk.green("✔")} Bundle uploaded securely.`);
+
+    console.log(`\n✨ ${chalk.bold.green("Success!")} ${result.message}\n`);
+
+    if (result.request && result.request.id) {
+      console.log(chalk.bold("Publish Details:"));
+      console.log(chalk.gray("───────────────────────────────────"));
+      console.log(`  Request ID: ${chalk.cyan(result.request.id)}`);
+      console.log(`  Game ID: ${chalk.cyan(gameId)}`);
+      console.log(`  Game Name: ${chalk.cyan(gameName)}`);
+      console.log(`  Version: ${chalk.cyan(version)}`);
+      console.log(`  Bundle: ${chalk.cyan(result.request.bundle_url)}`);
+      console.log(`  Status: ${chalk.yellow("Under Review")}`);
+      console.log(chalk.gray("───────────────────────────────────\n"));
+
+      console.log(chalk.blue("ℹ️ Your game is now under review."));
+      if (developerEmail) {
+        console.log(
+          chalk.blue(
+            `An email will be sent to ${chalk.bold(
+              developerEmail,
+            )} informing if it was approved or rejected (with reasons).`,
+          ),
+        );
+      }
+    }
+  } catch (error: any) {
+    console.error(chalk.red(`\n✖ Publish failed: ${error.message}`));
+    process.exit(1);
+  }
+}

package/src/config/constants.ts

@@ -0,0 +1,2 @@
+export const SUPABASE_URL = "https://uiexmpkqvbkprhifiyaj.supabase.co";
+export const SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InVpZXhtcGtxdmJrcHJoaWZpeWFqIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzE4NTY3ODIsImV4cCI6MjA4NzQzMjc4Mn0.OHI8RBANokqtgRBytBTO0FiB_p_JHjq0mW2wwfzlZDs";

package/src/index.ts

@@ -0,0 +1,39 @@
+import { program } from "commander";
+import { initCommand } from "./commands/init";
+import { publishCommand } from "./commands/publish";
+import chalk from "chalk";
+
+export function run() {
+  program
+    .name("brick-engine-cli")
+    .description("CLI to scaffold Brick Engine projects")
+    .version("1.0.0");
+
+  program
+    .command("init <name>")
+    .description("Initialize a new Brick Engine project")
+    .action(async (name) => {
+      try {
+        await initCommand(name);
+      } catch (error: any) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("publish")
+    .description("Publish your game to the Brick Engine Artifactory")
+    .option("-u, --url <url>", "Supabase URL")
+    .option("-k, --key <key>", "Supabase Anon Key")
+    .action(async (options) => {
+      try {
+        await publishCommand(options);
+      } catch (error: any) {
+        console.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  program.parse(process.argv);
+}

package/templates/.prettierrc

@@ -0,0 +1,8 @@
+{
+    "trailingComma": "all",
+    "singleQuote": true,
+    "endOfLine": "lf",
+    "tabWidth": 4,
+    "arrowParens": "avoid",
+    "printWidth": 160
+}

package/templates/eslint.config.mjs

@@ -0,0 +1,18 @@
+import globals from 'globals';
+import pluginJs from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default [
+    {
+        ignores: ['dist/', 'node_modules/'],
+    },
+    // Base config for all files
+    pluginJs.configs.recommended,
+    ...tseslint.configs.recommended,
+
+    // Browser globals for most files
+    {
+        files: ['**/*.{js,ts}'],
+        languageOptions: { globals: globals.browser },
+    },
+];

package/templates/src/bootstrap.ts

@@ -0,0 +1,4 @@
+import { bootstrap } from 'brick-engine-js';
+import MyGame from '.';
+
+bootstrap(MyGame);

package/templates/src/index.ts

@@ -0,0 +1,104 @@
+import { Game, FontSize, ControlKey, ControlEventType, Sound, FontAlign, FontVerticalAlign, Color } from 'brick-engine-js';
+
+export default class MyGame extends Game {
+    y = 0;
+    x = 5;
+
+    /**
+     * 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.subscribe(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;
+            },
+            serialize: () => {
+                return JSON.stringify({ x: this.x, y: this.y });
+            },
+        });
+    }
+
+    /**
+     * 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.
+     */
+    update(deltaTime: number): void {
+        const actualCoordinate = { x: this.x, y: this.y };
+
+        if (!this.modules.grid.isValidCoordinate(actualCoordinate)) {
+            this.modules.state.triggerGameOver();
+        }
+
+        this.modules.score.increaseScore(1);
+    }
+
+    /**
+     * 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.
+     */
+    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 });
+    }
+
+    /**
+     * Rendered every frame when the device is ON but the game hasn't started.
+     * Usually displays the title and "Press Start" instructions.
+     */
+    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.setTextSize(FontSize.SMALL);
+        text.textOnDisplay('running on', { x: 0.5, y: 0.48 });
+        text.textOnDisplay('drawTitleScreen', { x: 0.5, y: 0.55 });
+
+        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.
+     */
+    drawGameOverScreen(): void {
+        this.modules.text.setTextAlign(FontAlign.CENTER, FontVerticalAlign.CENTER);
+
+        this.modules.text.textOnDisplay('GAME OVER', { x: 0.5, y: 0.5 });
+
+        this.modules.text.setTextSize(FontSize.MEDIUM);
+        this.modules.text.textOnDisplay('PRESS START', { x: 0.5, y: 0.8 });
+    }
+
+    getGameId() {
+        return 'tetris';
+    }
+}

package/templates/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "outDir": "./dist/",
+        "noImplicitAny": true,
+        "module": "es6",
+        "target": "es5",
+        "allowJs": true,
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "types": ["node"]
+    },
+    "include": ["src/**/*", "global.d.ts"]
+}

package/templates/webpack.config.js

@@ -0,0 +1,98 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import webpack from 'webpack';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
+import CopyWebpackPlugin from 'copy-webpack-plugin';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export default (env = {}, argv) => {
+    const isProduction = argv.mode === 'production';
+    const bundleMode = env.bundle || 'bundle'; // 'standalone' or 'bundle'
+
+    // Dynamically find the engine root using require.resolve
+    const engineRoot = path.dirname(require.resolve('brick-engine-js/package.json'));
+
+    const config = {
+        mode: isProduction ? 'production' : 'development',
+        // In 'bundle' mode, we bundle ONLY the game class
+        // In 'standalone' mode, we load the engine with the user's game
+        entry: {
+            app: path.resolve(__dirname, 'src/bootstrap.ts'),
+        },
+        output: {
+            filename: 'game.bundle.js',
+            path: path.resolve(__dirname, 'dist'),
+            clean: true,
+        },
+        devtool: isProduction ? false : 'source-map',
+        module: {
+            rules: [
+                {
+                    test: /\.tsx?$/,
+                    use: 'ts-loader',
+                    exclude: /node_modules\/(?!brick-engine-js)/,
+                },
+                {
+                    test: /\.css$/i,
+                    use: [MiniCssExtractPlugin.loader, 'css-loader'],
+                },
+            ],
+        },
+        resolve: {
+            extensions: ['.tsx', '.ts', '.js'],
+            symlinks: true,
+            alias: {
+                'brick-engine-js': path.resolve(engineRoot, 'dist/game.bundle.js'),
+            },
+        },
+        externals: {
+            p5: 'p5',
+        },
+        plugins: [
+            new webpack.DefinePlugin({
+                'process.env.APP_MODE': JSON.stringify('client'),
+                'process.env.SUPABASE_URL': JSON.stringify(process.env.SUPABASE_URL || ''),
+                'process.env.SUPABASE_ANON_KEY': JSON.stringify(process.env.SUPABASE_ANON_KEY || ''),
+            }),
+            new MiniCssExtractPlugin({
+                filename: 'style.css',
+            }),
+        ],
+        devServer: {
+            static: path.resolve(__dirname, 'dist'),
+            port: 8080,
+            open: true,
+            hot: true,
+        },
+    };
+
+    if (bundleMode === 'standalone') {
+        // Plugins only for standalone mode
+        config.plugins.push(
+            new HtmlWebpackPlugin({
+                template: path.resolve(engineRoot, 'dist/index.html'),
+                favicon: path.resolve(engineRoot, 'dist/favicon.ico'),
+                inject: false,
+            }),
+            new CopyWebpackPlugin({
+                patterns: [
+                    {
+                        from: path.resolve(engineRoot, 'dist/vendor/p5.min.js'),
+                        to: 'vendor/p5.min.js',
+                    },
+                    { from: path.resolve(engineRoot, 'dist/css'), to: 'css' },
+                    { from: path.resolve(engineRoot, 'dist/images'), to: 'images' },
+                    { from: path.resolve(engineRoot, 'dist/sounds'), to: 'sounds' },
+                    { from: path.resolve(engineRoot, 'dist/fonts'), to: 'fonts' },
+                ],
+            }),
+        );
+    }
+
+    return config;
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "outDir": "dist",
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "declaration": true
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
+}