@erik9994857/cag 1.0.0

package/src/api/pull-api.js

@@ -0,0 +1,331 @@
+const path = require("path");
+const fs = require("fs");
+
+class PullAPI {
+  constructor(resourceMap, resourcesPath) {
+    this.resourceMap = resourceMap || {};
+    this.resourcesPath = resourcesPath || process.cwd();
+    this.retrievedModels = {};
+    this.defaultModelsPath = path.join(__dirname, "..", "models", "defaults");
+    this.supportedFormats = [".bbmodel"];
+    this.supportedTextures = [".png", ".jpg", ".jpeg", ".bmp", ".tga"];
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "retrieve":
+        return this.retrieve(params);
+      case "search":
+        return this.search(params);
+      case "list":
+        return this.list();
+      default:
+        throw new Error("Unknown Pull.API action: " + action);
+    }
+  }
+
+  retrieve(params) {
+    if (!params || params.length === 0) {
+      throw new Error("retrieve requires a model ID parameter");
+    }
+
+    var modelId = params[0];
+
+    if (this.retrievedModels[modelId]) {
+      return this.retrievedModels[modelId];
+    }
+
+    var result = this.findInDefaults(modelId);
+
+    if (!result) {
+      result = this.findInResources(modelId);
+    }
+
+    if (!result) {
+      throw new Error("Model not found: " + modelId);
+    }
+
+    result = this.validateModel(result);
+
+    this.retrievedModels[modelId] = result;
+
+    return result;
+  }
+
+  findInDefaults(modelId) {
+    var lowerName = modelId.toLowerCase();
+    var modelPath = path.join(this.defaultModelsPath, lowerName + ".bbmodel");
+    var texturePath = path.join(this.defaultModelsPath, lowerName + ".png");
+
+    if (!fs.existsSync(modelPath)) {
+      return null;
+    }
+
+    var result = {
+      id: modelId,
+      source: "defaults",
+      modelPath: modelPath,
+      texturePath: null,
+      modelData: null,
+      textureData: null,
+      uvMappings: [],
+      valid: false
+    };
+
+    if (fs.existsSync(texturePath)) {
+      result.texturePath = texturePath;
+    }
+
+    result.modelData = this.loadBBModel(modelPath);
+    result.uvMappings = this.extractUVMappings(result.modelData);
+
+    if (result.texturePath) {
+      result.textureData = this.loadTextureInfo(result.texturePath);
+    }
+
+    return result;
+  }
+
+  findInResources(modelId) {
+    if (this.resourceMap[modelId]) {
+      var res = this.resourceMap[modelId];
+      return {
+        id: modelId,
+        source: "resources",
+        modelPath: res.model,
+        texturePath: res.texture,
+        modelData: res.model ? this.loadBBModel(res.model) : null,
+        textureData: res.texture ? this.loadTextureInfo(res.texture) : null,
+        uvMappings: [],
+        valid: false
+      };
+    }
+
+    return null;
+  }
+
+  loadBBModel(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    var raw = fs.readFileSync(filePath, "utf-8");
+    var data;
+
+    try {
+      data = JSON.parse(raw);
+    } catch (e) {
+      throw new Error("Invalid .bbmodel file: " + filePath);
+    }
+
+    return {
+      formatVersion: data.meta ? data.meta.format_version : "unknown",
+      modelIdentifier: data.name || path.basename(filePath, ".bbmodel"),
+      resolution: data.resolution || { width: 16, height: 16 },
+      elements: data.elements || [],
+      textures: data.textures || [],
+      outliner: data.outliner || []
+    };
+  }
+
+  loadTextureInfo(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    var ext = path.extname(filePath).toLowerCase();
+    var buffer = fs.readFileSync(filePath);
+    var width = 0;
+    var height = 0;
+
+    if (ext === ".png" && buffer.length >= 24) {
+      width = buffer.readUInt32BE(16);
+      height = buffer.readUInt32BE(20);
+    }
+
+    return {
+      path: filePath,
+      width: width,
+      height: height,
+      format: ext.substring(1),
+      size: buffer.length
+    };
+  }
+
+  extractUVMappings(modelData) {
+    if (!modelData || !modelData.elements) {
+      return [];
+    }
+
+    var mappings = [];
+    var faceNames = ["north", "south", "east", "west", "up", "down"];
+
+    for (var i = 0; i < modelData.elements.length; i++) {
+      var element = modelData.elements[i];
+      if (!element.faces) {
+        continue;
+      }
+
+      for (var j = 0; j < faceNames.length; j++) {
+        var faceName = faceNames[j];
+        if (element.faces[faceName]) {
+          var face = element.faces[faceName];
+          mappings.push({
+            element: element.name || "element_" + i,
+            face: faceName,
+            uv: face.uv || [0, 0, 16, 16],
+            textureIndex: face.texture !== undefined ? face.texture : 0,
+            supported: true
+          });
+        }
+      }
+    }
+
+    return mappings;
+  }
+
+  validateModel(result) {
+    if (!result.modelData) {
+      result.valid = false;
+      return result;
+    }
+
+    if (result.uvMappings.length === 0 && result.modelData) {
+      result.uvMappings = this.extractUVMappings(result.modelData);
+    }
+
+    if (result.textureData && result.textureData.width > 0) {
+      result.uvMappings = this.fixUVMappings(result.uvMappings, result.textureData);
+    }
+
+    result.valid = true;
+    return result;
+  }
+
+  fixUVMappings(mappings, textureData) {
+    var fixed = [];
+
+    for (var i = 0; i < mappings.length; i++) {
+      var mapping = mappings[i];
+      var uv = mapping.uv;
+      var needsFix = false;
+
+      if (uv[0] < 0 || uv[1] < 0 || uv[2] < 0 || uv[3] < 0) {
+        needsFix = true;
+      }
+
+      if (uv[2] > textureData.width || uv[3] > textureData.height) {
+        needsFix = true;
+      }
+
+      if (uv[0] > uv[2] || uv[1] > uv[3]) {
+        needsFix = true;
+      }
+
+      if (needsFix) {
+        var fixedMapping = {};
+        for (var key in mapping) {
+          fixedMapping[key] = mapping[key];
+        }
+        fixedMapping.uv = [
+          Math.max(0, Math.min(uv[0], textureData.width)),
+          Math.max(0, Math.min(uv[1], textureData.height)),
+          Math.max(0, Math.min(uv[2], textureData.width)),
+          Math.max(0, Math.min(uv[3], textureData.height))
+        ];
+        if (fixedMapping.uv[0] > fixedMapping.uv[2]) {
+          var temp = fixedMapping.uv[0];
+          fixedMapping.uv[0] = fixedMapping.uv[2];
+          fixedMapping.uv[2] = temp;
+        }
+        if (fixedMapping.uv[1] > fixedMapping.uv[3]) {
+          var temp2 = fixedMapping.uv[1];
+          fixedMapping.uv[1] = fixedMapping.uv[3];
+          fixedMapping.uv[3] = temp2;
+        }
+        fixedMapping.wasFixed = true;
+        fixedMapping.supported = true;
+        fixed.push(fixedMapping);
+      } else {
+        mapping.supported = true;
+        fixed.push(mapping);
+      }
+    }
+
+    return fixed;
+  }
+
+  search(params) {
+    if (!params || params.length === 0) {
+      throw new Error("search requires a query parameter");
+    }
+
+    var query = params[0].toLowerCase();
+    var results = [];
+
+    var defaultFiles = [];
+    if (fs.existsSync(this.defaultModelsPath)) {
+      try {
+        defaultFiles = fs.readdirSync(this.defaultModelsPath);
+      } catch (e) {
+        defaultFiles = [];
+      }
+    }
+
+    for (var i = 0; i < defaultFiles.length; i++) {
+      var file = defaultFiles[i];
+      var ext = path.extname(file).toLowerCase();
+      if (ext === ".bbmodel") {
+        var name = path.basename(file, ext);
+        if (name.toLowerCase().indexOf(query) !== -1) {
+          results.push({
+            id: name,
+            source: "defaults",
+            type: "model"
+          });
+        }
+      }
+    }
+
+    var resourceNames = Object.keys(this.resourceMap);
+    for (var j = 0; j < resourceNames.length; j++) {
+      if (resourceNames[j].toLowerCase().indexOf(query) !== -1) {
+        results.push({
+          id: resourceNames[j],
+          source: "resources",
+          type: this.resourceMap[resourceNames[j]].model ? "model" : "texture"
+        });
+      }
+    }
+
+    return results;
+  }
+
+  list() {
+    var results = [];
+
+    var retrievedKeys = Object.keys(this.retrievedModels);
+    for (var i = 0; i < retrievedKeys.length; i++) {
+      var model = this.retrievedModels[retrievedKeys[i]];
+      results.push({
+        id: model.id,
+        source: model.source,
+        valid: model.valid,
+        hasTexture: model.texturePath !== null,
+        uvCount: model.uvMappings.length
+      });
+    }
+
+    return results;
+  }
+
+  isRetrieved(modelId) {
+    return this.retrievedModels[modelId] !== undefined;
+  }
+
+  getRetrieved(modelId) {
+    return this.retrievedModels[modelId] || null;
+  }
+}
+
+module.exports = PullAPI;

package/src/api/worldgen-api.js

@@ -0,0 +1,332 @@
+class WorldGenAPI {
+  constructor(modelAPI) {
+    this.modelAPI = modelAPI;
+    this.worlds = {};
+    this.activeWorld = null;
+    this.defaultWorldSize = { x: 64, y: 32, z: 64 };
+    this.defaultSeaLevel = 12;
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "generate":
+        return this.generate(params);
+      case "destroy":
+        return this.destroy(params);
+      case "modify":
+        return this.modify(params);
+      default:
+        throw new Error("Unknown WorldGen.API action: " + action);
+    }
+  }
+
+  generate(params) {
+    if (!params || params.length === 0) {
+      throw new Error("generate requires parameters");
+    }
+
+    var config = this.parseGenerateParams(params);
+
+    var worldId = config.worldName || "default";
+
+    var world = {
+      id: worldId,
+      size: config.size || this.defaultWorldSize,
+      layers: {},
+      blocks: [],
+      generated: false,
+      seed: config.seed || Math.floor(Math.random() * 2147483647),
+      createdAt: new Date().toISOString()
+    };
+
+    if (config.topLayer) {
+      var topModel = null;
+      if (this.modelAPI && this.modelAPI.isModelLoaded(config.topLayer)) {
+        topModel = this.modelAPI.getLoadedModel(config.topLayer);
+      } else if (this.modelAPI) {
+        topModel = this.modelAPI.useModel([config.topLayer]);
+      }
+
+      world.layers.top = {
+        model: config.topLayer,
+        modelData: topModel,
+        yLevel: world.size.y - 1
+      };
+    }
+
+    if (config.bottomLayer) {
+      var bottomModel = null;
+      if (this.modelAPI && this.modelAPI.isModelLoaded(config.bottomLayer)) {
+        bottomModel = this.modelAPI.getLoadedModel(config.bottomLayer);
+      } else if (this.modelAPI) {
+        bottomModel = this.modelAPI.useModel([config.bottomLayer]);
+      }
+
+      world.layers.bottom = {
+        model: config.bottomLayer,
+        modelData: bottomModel,
+        yLevel: 0
+      };
+    }
+
+    if (config.fillLayer) {
+      var fillModel = null;
+      if (this.modelAPI && this.modelAPI.isModelLoaded(config.fillLayer)) {
+        fillModel = this.modelAPI.getLoadedModel(config.fillLayer);
+      } else if (this.modelAPI) {
+        fillModel = this.modelAPI.useModel([config.fillLayer]);
+      }
+
+      world.layers.fill = {
+        model: config.fillLayer,
+        modelData: fillModel,
+        yLevelStart: 1,
+        yLevelEnd: world.size.y - 2
+      };
+    }
+
+    world.blocks = this.generateBlocks(world);
+    world.generated = true;
+
+    this.worlds[worldId] = world;
+    this.activeWorld = worldId;
+
+    return {
+      worldId: worldId,
+      size: world.size,
+      layers: Object.keys(world.layers),
+      blockCount: world.blocks.length,
+      seed: world.seed
+    };
+  }
+
+  parseGenerateParams(params) {
+    var config = {};
+    var i = 0;
+
+    while (i < params.length) {
+      var param = params[i];
+
+      if (param === "world") {
+        i++;
+        continue;
+      }
+
+      if (param === "top" && i + 1 < params.length && params[i + 1] === "layer") {
+        i += 2;
+        if (i < params.length && params[i] === "=") {
+          i++;
+        }
+        if (i < params.length) {
+          config.topLayer = params[i];
+        }
+        i++;
+        continue;
+      }
+
+      if (param === "bottom" && i + 1 < params.length && params[i + 1] === "layer") {
+        i += 2;
+        if (i < params.length && params[i] === "=") {
+          i++;
+        }
+        if (i < params.length) {
+          config.bottomLayer = params[i];
+        }
+        i++;
+        continue;
+      }
+
+      if (param === "fill" && i + 1 < params.length && params[i + 1] === "layer") {
+        i += 2;
+        if (i < params.length && params[i] === "=") {
+          i++;
+        }
+        if (i < params.length) {
+          config.fillLayer = params[i];
+        }
+        i++;
+        continue;
+      }
+
+      if (param === "size") {
+        if (i + 1 < params.length && params[i + 1] === "=") {
+          i += 2;
+        } else {
+          i++;
+        }
+        if (i < params.length) {
+          var sizeVal = parseInt(params[i], 10);
+          if (!isNaN(sizeVal)) {
+            config.size = { x: sizeVal, y: sizeVal, z: sizeVal };
+          }
+        }
+        i++;
+        continue;
+      }
+
+      if (param === "seed") {
+        if (i + 1 < params.length && params[i + 1] === "=") {
+          i += 2;
+        } else {
+          i++;
+        }
+        if (i < params.length) {
+          var seedVal = parseInt(params[i], 10);
+          if (!isNaN(seedVal)) {
+            config.seed = seedVal;
+          }
+        }
+        i++;
+        continue;
+      }
+
+      if (param === "name") {
+        if (i + 1 < params.length && params[i + 1] === "=") {
+          i += 2;
+        } else {
+          i++;
+        }
+        if (i < params.length) {
+          config.worldName = params[i];
+        }
+        i++;
+        continue;
+      }
+
+      i++;
+    }
+
+    return config;
+  }
+
+  generateBlocks(world) {
+    var blocks = [];
+    var size = world.size;
+
+    for (var x = 0; x < size.x; x++) {
+      for (var z = 0; z < size.z; z++) {
+        var height = this.getHeight(x, z, world.seed, size.y);
+
+        for (var y = 0; y <= height; y++) {
+          var blockType = "air";
+
+          if (y === height && world.layers.top) {
+            blockType = world.layers.top.model;
+          } else if (y === 0 && world.layers.bottom) {
+            blockType = world.layers.bottom.model;
+          } else if (world.layers.fill) {
+            blockType = world.layers.fill.model;
+          }
+
+          if (blockType !== "air") {
+            blocks.push({
+              x: x,
+              y: y,
+              z: z,
+              type: blockType
+            });
+          }
+        }
+      }
+    }
+
+    return blocks;
+  }
+
+  getHeight(x, z, seed, maxHeight) {
+    var hash = ((x * 374761393 + z * 668265263 + seed) & 0x7fffffff) % 1000;
+    var normalized = hash / 1000.0;
+    var height = Math.floor(normalized * (maxHeight * 0.4)) + Math.floor(maxHeight * 0.3);
+    return Math.min(height, maxHeight - 1);
+  }
+
+  destroy(params) {
+    if (!params || params.length === 0) {
+      if (this.activeWorld) {
+        var id = this.activeWorld;
+        delete this.worlds[id];
+        this.activeWorld = null;
+        return { destroyed: id };
+      }
+      throw new Error("No active world to destroy");
+    }
+
+    var worldId = params[0];
+
+    if (!this.worlds[worldId]) {
+      throw new Error("World not found: " + worldId);
+    }
+
+    delete this.worlds[worldId];
+
+    if (this.activeWorld === worldId) {
+      this.activeWorld = null;
+    }
+
+    return { destroyed: worldId };
+  }
+
+  modify(params) {
+    if (!params || params.length < 2) {
+      throw new Error("modify requires at least a world ID and modification type");
+    }
+
+    var worldId = params[0];
+    var modType = params[1];
+
+    if (worldId === "active") {
+      worldId = this.activeWorld;
+    }
+
+    if (!worldId || !this.worlds[worldId]) {
+      throw new Error("World not found: " + (worldId || "none"));
+    }
+
+    var world = this.worlds[worldId];
+
+    if (modType === "setblock") {
+      if (params.length < 6) {
+        throw new Error("setblock requires x y z blockType");
+      }
+      var bx = parseInt(params[2], 10);
+      var by = parseInt(params[3], 10);
+      var bz = parseInt(params[4], 10);
+      var btype = params[5];
+
+      world.blocks.push({ x: bx, y: by, z: bz, type: btype });
+      return { modified: worldId, action: "setblock", position: [bx, by, bz], type: btype };
+    }
+
+    if (modType === "clear") {
+      var count = world.blocks.length;
+      world.blocks = [];
+      return { modified: worldId, action: "clear", blocksRemoved: count };
+    }
+
+    throw new Error("Unknown modification type: " + modType);
+  }
+
+  getWorld(worldId) {
+    return this.worlds[worldId || this.activeWorld] || null;
+  }
+
+  getActiveWorld() {
+    if (!this.activeWorld) {
+      return null;
+    }
+    return this.worlds[this.activeWorld];
+  }
+
+  listWorlds() {
+    return Object.keys(this.worlds).map(function (id) {
+      return {
+        id: id,
+        size: this.worlds[id].size,
+        blockCount: this.worlds[id].blocks.length,
+        active: id === this.activeWorld
+      };
+    }.bind(this));
+  }
+}
+
+module.exports = WorldGenAPI;