mcaddon-generator 1.0.0

package/addon_files/BP/manifest.json

@@ -0,0 +1,27 @@
+{
+    "format_version": 3,
+    "header": {
+        "name": "",
+        "description": "",
+        "min_engine_version": {},
+        "version": "1.0.0",
+        "uuid": ""
+    },
+    "metadata": {
+        "authors": [
+        ],
+        "generated_with": {
+            "mcaddon": [
+                "1.0.0"
+            ]
+        }
+    },
+    "modules": [
+        {
+            "type": "data",
+            "description": "Allows the addition of blocks, items, and entities into your addon",
+            "version": "1.0.0",
+            "uuid": ""
+        }
+    ]
+}

package/addon_files/BP/scripts/output/main.js

@@ -0,0 +1,4 @@
+import { world } from "@minecraft/server";
+world.afterEvents.worldLoad.subscribe(()=>{
+    console.log("Addon is functioning!")
+})

package/addon_files/BP/scripts/source/main.ts

@@ -0,0 +1,5 @@
+import { world } from "@minecraft/server";
+
+world.afterEvents.worldLoad.subscribe(()=>{
+    console.log("Addon is functioning!");
+})

package/addon_files/RP/manifest.json

@@ -0,0 +1,27 @@
+{
+    "format_version": 3,
+    "header": {
+        "name": "",
+        "description": "",
+        "min_engine_version": {},
+        "version": "1.0.0",
+        "uuid": ""
+    },
+    "metadata": {
+        "authors": [
+        ],
+        "generated_with": {
+            "mcaddon": [
+                "1.0.0"
+            ]
+        }
+    },
+    "modules": [
+        {
+            "type": "resources",
+            "description": "Allows the addition of textures, models, sounds, and more into your addon",
+            "version": "1.0.0",
+            "uuid": ""
+        }
+    ]
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "mcaddon-generator",
+  "version": "1.0.0",
+  "description": "Enables creators to be more efficient in creating and packaging their addons",
+  "license": "ISC",
+  "author": "AngrySalt",
+  "type": "commonjs",
+  "main": "scripts/output/index.js",
+  "keywords": [
+    "minecraft"
+  ],
+  "bin": {
+    "mcaddon": "scripts/output/index.js"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "commander": "^14.0.3",
+    "uuid": "^13.0.0",
+    "zip-a-folder": "^6.1.0"
+  }
+}

package/scripts/output/commands/create/createBP.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateBP = CreateBP;
+const node_crypto_1 = require("node:crypto");
+const path = require("node:path");
+const createPack_1 = require("./createPack");
+const __1 = require("../..");
+const BASE_BP_FOLDER = path.join(createPack_1.addonFilesFolder, "BP");
+function CreateBP(bpUUID, rpUUID, args, destinationDirectory) {
+    var _a;
+    const base_manifest = require(path.join(BASE_BP_FOLDER, "manifest.json"));
+    let manifest = (0, createPack_1.ApplySharedManifestInfo)(base_manifest, args, bpUUID, (args.rp && rpUUID) || undefined);
+    if (args.script) {
+        manifest.modules.push({
+            type: "script",
+            language: "javascript",
+            entry: "scripts/output/main.js",
+            description: "Allows you to add scripts that can interact with your minecraft world through APIs",
+            uuid: (0, node_crypto_1.randomUUID)(),
+            version: "1.0.0"
+        });
+        manifest.dependencies = (_a = manifest.dependencies) !== null && _a !== void 0 ? _a : [];
+        manifest.dependencies.push({
+            module_name: "@minecraft/server",
+            version: args.script_version
+        });
+    }
+    const filePath = (0, __1.GetPackFolder)(destinationDirectory, __1.PackType.BP, args);
+    (0, createPack_1.SavePackFiles)(manifest, BASE_BP_FOLDER, filePath, args.script == false ?
+        ((source) => !(source.endsWith("scripts") || source.endsWith("package.json") || source.endsWith("tsconfig.json")))
+        : undefined);
+    return filePath;
+}

package/scripts/output/commands/create/createPack.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addonFilesFolder = void 0;
+exports.ApplySharedManifestInfo = ApplySharedManifestInfo;
+exports.SavePackFiles = SavePackFiles;
+const node_crypto_1 = require("node:crypto");
+const path = require("node:path");
+const filesystem = require("node:fs");
+function FormatVersionNumber(args, version) {
+    return args.format_version == 3 ? version : version.split(".").map(parseFloat);
+}
+function ApplySharedManifestInfo(manifest, args, uuid, dependentId) {
+    manifest.header.name = args.name;
+    manifest.header.description = args.description;
+    manifest.header.uuid = uuid;
+    manifest.header.min_engine_version = FormatVersionNumber(args, args.engine_version);
+    manifest.modules[0].uuid = (0, node_crypto_1.randomUUID)();
+    if (dependentId) {
+        manifest.dependencies = [{
+                uuid: dependentId,
+                version: "1.0.0"
+            }];
+    }
+    manifest.metadata.authors.push(args.author);
+    return manifest;
+}
+exports.addonFilesFolder = path.join(__dirname, "..", "..", "..", "..", "addon_files");
+function SavePackFiles(manifest, sourceDirectory, directory, filter) {
+    filesystem.cpSync(sourceDirectory, directory, { recursive: true, filter });
+    filesystem.writeFile(path.join(directory, "manifest.json"), JSON.stringify(manifest, undefined, 4), (e) => {
+        if (e)
+            console.error(`Error when writing BP manifest file: ${e}`);
+    });
+}

package/scripts/output/commands/create/createRP.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateRP = CreateRP;
+const path = require("node:path");
+const createPack_1 = require("./createPack");
+const __1 = require("../..");
+const BASE_RP_FOLDER = path.join(createPack_1.addonFilesFolder, "RP");
+function CreateRP(rpUUID, bpUUID, args, destinationDirectory) {
+    const base_manifest = require(path.join(BASE_RP_FOLDER, "manifest.json"));
+    const manifest = (0, createPack_1.ApplySharedManifestInfo)(base_manifest, args, rpUUID, bpUUID);
+    const filePath = (0, __1.GetPackFolder)(destinationDirectory, __1.PackType.RP, args);
+    (0, createPack_1.SavePackFiles)(manifest, BASE_RP_FOLDER, filePath);
+    return filePath;
+}

package/scripts/output/commands/create/main.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateCommand = void 0;
+const commander_1 = require("commander");
+const node_process_1 = require("node:process");
+const node_crypto_1 = require("node:crypto");
+const createBP_1 = require("./createBP");
+const createRP_1 = require("./createRP");
+const path = require("node:path");
+const filesystem = require("node:fs");
+const readline = require("node:readline");
+const __1 = require("../..");
+let rl;
+function AskQuestion(question, defaultAnswer) {
+    question += `? (${defaultAnswer}): `;
+    return new Promise((r) => {
+        rl.question(question, (answer) => r(answer.length > 0 ? answer : defaultAnswer));
+    });
+}
+function ExecuteCreateCommand(args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (args.beta)
+            args.script_version = "beta";
+        (0, __1.AssertArgs)(args.preview && args.here, "--preview or --here must be false");
+        (0, __1.AssertArgs)(!(args.bp === true || args.rp === true), "Must either output a BP file, a RP file, or both. Cannot do neither");
+        rl = readline.createInterface({ input: node_process_1.stdin, output: node_process_1.stdout });
+        if (!args.name)
+            args.name = yield AskQuestion("name", "PACK_NAME");
+        if (!args.description)
+            args.description = yield AskQuestion("description", "pack.description");
+        if (!args.author)
+            args.author = yield AskQuestion("author", "");
+        rl.close();
+        let bpUUID = (0, node_crypto_1.randomUUID)();
+        let rpUUID = (0, node_crypto_1.randomUUID)();
+        const destinationDirectory = (0, __1.GetTargetDirectory)(args);
+        if (!filesystem.existsSync(destinationDirectory)) {
+            console.error(`${destinationDirectory} doesn't exist!`);
+            (0, node_process_1.exit)(1);
+        }
+        const workspaceData = {
+            folders: [],
+            settings: {}
+        };
+        if (args.bp)
+            workspaceData.folders.push({ path: (0, createBP_1.CreateBP)(bpUUID, rpUUID, args, destinationDirectory) });
+        if (args.rp)
+            workspaceData.folders.push({ path: (0, createRP_1.CreateRP)(rpUUID, bpUUID, args, destinationDirectory) });
+        if (!args.vscode)
+            return;
+        filesystem.writeFileSync(path.join(process.cwd(), `${args.name}.code-workspace`), JSON.stringify(workspaceData, undefined, 4));
+    });
+}
+exports.CreateCommand = new commander_1.Command("create")
+    .description("Used to create both BPs and RPs for MCBE")
+    .option("--name, -n <NAME>", "Set the name used for both packs")
+    .option("--description, -d <DESCRIPTION>", "Set the description used for both packs")
+    .option("--author, -a <AUTHOR>", "Specify the author of the project")
+    .option("--bp [VALUE]", "Whether or not to create a behavior pack", true)
+    .option("--no-bp")
+    .option("--rp [VALUE]", "Whether or not to create a resource pack", true)
+    .option("--no-rp")
+    .option("--here, -h", "Output the packs into the current directory. By default the pack files will go into your minecraft development folders", false)
+    .option("--preview, -p", "Will output your packs into the preview version of the game", false)
+    .option("--script [VALUE]", "Whether or not to use the script api", true)
+    .option("--no-script")
+    .option("--script_version <VERSION>", "What version to use for the @minecraft/server api", "2.6.0")
+    .option("--beta, -b", "Shorthand for --script_version beta", false)
+    .option("--engine_version, -v <VERSION>", "The minimum engine version", "1.26.0")
+    .option("--format_version <VERSION>", "The format_version of the manifest", parseInt, 3)
+    .option("--vscode [VALUE]", "Whether or not to output a vscode workspace file in the current directory", true)
+    .option("--no-vscode")
+    .action(ExecuteCreateCommand);

package/scripts/output/commands/pack.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACK_COMMAND = void 0;
+const commander_1 = require("commander");
+const index_1 = require("../index");
+const path = require("node:path");
+const filesystem = require("node:fs");
+const node_process_1 = require("node:process");
+const zip_a_folder_1 = require("zip-a-folder");
+exports.PACK_COMMAND = new commander_1.Command()
+    .name("pack")
+    .description("Packs up your existing pack to be downloaded and imported by other players")
+    .requiredOption("--name, -n <NAME>", "The name of your pack(s)")
+    .option("--here, -h [VALUE]", "Look for files in the current directory", false)
+    .option("--preview, -p", "Look for files in the Minecraft Preview directory", false)
+    .action((args) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, index_1.AssertArgs)(args.here && args.preview, "Either --preview or --here must be false");
+    const directory = (0, index_1.GetTargetDirectory)(args);
+    const bpFolder = (0, index_1.GetPackFolder)(directory, index_1.PackType.BP, args);
+    const rpFolder = (0, index_1.GetPackFolder)(directory, index_1.PackType.RP, args);
+    const newDirectory = path.join(process.cwd(), args.name);
+    const hasBp = filesystem.existsSync(bpFolder);
+    const hasRp = filesystem.existsSync(rpFolder);
+    if (!(hasBp || hasRp)) {
+        console.error("Couldn't find neither a BP or a RP");
+        (0, node_process_1.exit)(1);
+    }
+    if (filesystem.existsSync(newDirectory)) {
+        console.error("Folder with addon name already exists!");
+        (0, node_process_1.exit)(1);
+    }
+    if (hasBp) {
+        const newBpDirectory = path.join(newDirectory, "BP");
+        filesystem.cpSync(bpFolder, newBpDirectory, { recursive: true });
+        // Optimize the BP by removing un-needed files
+        const targetFiles = filesystem.globSync([path.join(newBpDirectory, "package.json"), path.join(newBpDirectory, "**", "tsconfig.json"), path.join(newBpDirectory, "scripts", "source"), path.join(newBpDirectory, "**", "*.ts")]);
+        targetFiles.forEach(filePath => {
+            if (filesystem.existsSync(filePath))
+                filesystem.rmSync(filePath, { recursive: true });
+        });
+    }
+    if (hasRp)
+        filesystem.cpSync(rpFolder, path.join(newDirectory, "RP"), { recursive: true });
+    yield (0, zip_a_folder_1.zip)(newDirectory, newDirectory + ".mcaddon");
+    filesystem.rmSync(newDirectory, { recursive: true });
+}));

package/scripts/output/index.js

@@ -0,0 +1,45 @@
+#! /usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackType = void 0;
+exports.GetTargetDirectory = GetTargetDirectory;
+exports.GetPackFolder = GetPackFolder;
+exports.AssertArgs = AssertArgs;
+const commander_1 = require("commander");
+const main_1 = require("./commands/create/main");
+const node_process_1 = require("node:process");
+const path = require("node:path");
+const os = require("node:os");
+const pack_1 = require("./commands/pack");
+const program = new commander_1.Command("mcaddon")
+    .description("Enables more efficient creation in MCBE addons")
+    .version("1.0.0")
+    .helpCommand(true)
+    .action(() => {
+    program.help();
+});
+function GetTargetDirectory({ here, preview }) {
+    const userDirectory = os.homedir();
+    const currentDirectory = process.cwd();
+    const minecraftDirectory = path.join(userDirectory, "AppData", "Roaming", "Minecraft Bedrock", "Users", "Shared", "games", "com.mojang");
+    const previewDirectory = path.join(userDirectory, "AppData", "Roaming", "Minecraft Bedrock Preview", "Users", "Shared", "games", "com.mojang");
+    return here ? currentDirectory : preview ? previewDirectory : minecraftDirectory;
+}
+var PackType;
+(function (PackType) {
+    PackType["BP"] = "BP";
+    PackType["RP"] = "RP";
+})(PackType || (exports.PackType = PackType = {}));
+function GetPackFolder(directory, packType, { name, here }) {
+    const nameNoSpaces = name.replace(" ", "") + packType;
+    return here ? path.join(directory, nameNoSpaces) : path.join(directory, packType == PackType.BP ? "development_behavior_packs" : "development_resource_packs", nameNoSpaces);
+}
+function AssertArgs(condition, errorMsg) {
+    if (condition) {
+        console.error(errorMsg);
+        (0, node_process_1.exit)(9);
+    }
+}
+program.addCommand(pack_1.PACK_COMMAND);
+program.addCommand(main_1.CreateCommand);
+program.parse();