Adding blocks and block properties

gen/base/builder.ts

@@ -1,3 +1,5 @@
+import { BlockProperty } from "../../src/block-properties/interface";
+import { Block } from "../../src/blocks/interface";
 import { Command } from "../../src/commands/interface";
 import { Enum } from "../../src/enums/interface";
 
@@ -10,6 +12,10 @@ export interface Builder {
   entities: Record<string, any>;
   /** [path]: content */
   files: Record<string, string>;
+  /** [id]: data */
+  blocks: Record<string, Block>;
+  /** [id]: data */
+  block_properties: Record<string, BlockProperty>;
 }
 
 

gen/blocks/import.ts

@@ -0,0 +1,45 @@
+import * as data from "../../bedrock-samples/metadata/vanilladata_modules/mojang-blocks.json";
+import { BlockProperty } from "../../src/block-properties/interface";
+import { Builder } from "../base/builder";
+
+export function generateFromBlocks(builder: Builder) {
+  blockProperties(builder);
+}
+
+function blockProperties(builder: Builder) {
+  data.block_properties.forEach((blockProperty) => {
+    const p = convertBlockProperty(blockProperty);
+
+    builder.block_properties[blockProperty.name] = p;
+  });
+}
+
+function convertBlockProperty(
+  property: (typeof data.block_properties)[0]
+): BlockProperty {
+  switch (property.type) {
+    case "bool":
+      return {
+        name: property.name,
+        type: "bool",
+        values: property.values.map((v) => v.value as boolean),
+      };
+
+    case "int":
+      return {
+        name: property.name,
+        type: "int",
+        values: property.values.map((v) => v.value as number),
+      };
+
+    case "string":
+      return {
+        name: property.name,
+        type: "string",
+        values: property.values.map((v) => v.value as string),
+      };
+
+    default:
+      throw new Error(`Unknown block property type: ${property.type}`);
+  }
+}

gen/generate-blocks.ts

@@ -0,0 +1,82 @@
+import { Builder } from "./base/builder";
+import { FileBuilder } from "./base/file-builder";
+
+export function saveBlocks(builder: Builder) {
+  saveAllBlocksProperties(builder);
+  saveAllBlocks(builder);
+}
+
+function saveAllBlocks(builder: Builder) {
+  const blocksFile = new FileBuilder("src/blocks/blocks.auto.ts");
+  blocksFile
+    .appendLine(`import { Block } from "./interface";`)
+    .appendLineBreak()
+    .appendLine(`export const Blocks: Record<string, Block> = {`);
+
+  for (const blockName in builder.blocks) {
+    const data = builder.blocks[blockName];
+
+    blocksFile.appendLine(
+      `  "${blockName}": ${JSON.stringify(data, null, 2)},`
+    );
+  }
+
+  blocksFile.appendLine(`};`);
+
+  //Namespace
+
+  blocksFile.save();
+}
+
+function saveAllBlocksProperties(builder: Builder) {
+  const propertiesFile = new FileBuilder(
+    "src/block-properties/block-properties.auto.ts"
+  );
+  propertiesFile
+      .appendLine(`import { BlockProperty } from "./interface";
+
+export type BlockPropertyNames = keyof typeof data;
+
+/** The namespace that access the block properties */
+export namespace BlockProperties {
+  /**
+   * Check if the given property name exists
+   * @param name The name of the property
+   * @returns true if the property exists
+   */
+  export function has(name: BlockPropertyNames): boolean {
+    return name in data;
+  }
+
+  /**
+   * Get the property by name
+   * @param name The name of the property
+   * @returns The property or undefined if not found
+   */
+  export function get(name: BlockPropertyNames): BlockProperty | undefined {
+    return (data as Record<string, BlockProperty>)[name];
+  }
+
+  /**
+   * Get all properties
+   * @returns All properties
+   */
+  export function properties(): Record<BlockPropertyNames, BlockProperty> {
+    return data as Record<BlockPropertyNames, BlockProperty>;
+  }
+}`)
+      .appendLineBreak()
+      .appendLine("const data = {");
+
+  for (const propertyName in builder.block_properties) {
+    const data = builder.block_properties[propertyName];
+
+    propertiesFile.appendLine(
+      `  "${propertyName}": ${JSON.stringify(data, null, 2)},`
+    );
+  }
+
+  propertiesFile.appendLine(`};`);
+
+  propertiesFile.save();
+}

gen/generate-enums.ts

@@ -87,7 +87,7 @@ function makeModules(builder: Builder) {
     .appendLine(`   * @returns The enum handler`)
     .appendLine(`   */`)
     .appendLine(
-      `  export function get(type: EnumType): EnumHandler | undefined {`
+      `  export function get(type: EnumType): EnumHandler {`
     )
     .appendLine(`    return Enums[type];`)
     .appendLine(`  }`);

gen/generate.ts

@@ -1,19 +1,23 @@
 import { Builder } from "./base/builder";
 import { generateFromCommands } from "./commands/import";
 import { writeFileSync } from "fs";
-import { toCamelCase, toKebabCase } from "./utility/case";
 import { saveEnums } from "./generate-enums";
 import { saveCommands } from "./generate-commands";
+import { saveBlocks } from "./generate-blocks";
+import { generateFromBlocks } from "./blocks/import";
 
 const builder: Builder = {
   commands: {},
   entities: {},
   enums: {},
   files: {},
+  block_properties: {},
+  blocks: {},
 };
 
 //Commands
 generateFromCommands(builder);
+generateFromBlocks(builder);
 
 //Commands export
 Builder.appendToIndex(builder, "src/commands/index.ts", "interface");
@@ -23,6 +27,9 @@ saveCommands(builder);
 Builder.appendToIndex(builder, "src/enums/index.ts", "interface");
 saveEnums(builder);
 
+//Blocks
+saveBlocks(builder);
+
 //Write files
 for (const filepath in builder.files) {
   const content = builder.files[filepath];