@erik9994857/cag 1.0.0

package/bin/cag

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+var CagCLI = require("../src/cli/cag-cli");
+
+var cli = new CagCLI(process.argv.slice(2));
+var exitCode = cli.run();
+
+if (typeof exitCode === "number") {
+  process.exitCode = exitCode;
+}

package/defaults/info.cag

@@ -0,0 +1,4 @@
+ID=PROJECTNAME.project.gg
+version=1.0.0
+codefolder=code
+resourcesfolder=resources

package/defaults/main.cag

@@ -0,0 +1,3 @@
+Depency Model.API
+Depency WorldGen.API
+Depency Pull.API

package/defaults/src/code/example.cagc

@@ -0,0 +1,5 @@
+Import Model.API
+Import WorldGen.API
+
+{function use Model.API UseModel Grass
+{function use WorldGen.API generate world top layer = Grass

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@erik9994857/cag",
+  "version": "1.0.0",
+  "description": "CaG — A code library and custom language for building 3D worlds with .cagc files, .bbmodel support, and auto UV mapping",
+  "main": "src/index.js",
+  "bin": {
+    "cag": "./bin/cag"
+  },
+  "files": [
+    "src/",
+    "bin/",
+    "defaults/"
+  ],
+  "scripts": {
+    "test": "node test/basic.test.js",
+    "start": "node src/index.js"
+  },
+  "keywords": [
+    "cag",
+    "game-engine",
+    "3d",
+    "bbmodel",
+    "blockbench",
+    "voxel",
+    "worldgen",
+    "custom-language"
+  ],
+  "author": "Erik9994857",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/api/api-registry.js

@@ -0,0 +1,144 @@
+const ModelAPI = require("./model-api");
+const WorldGenAPI = require("./worldgen-api");
+const PullAPI = require("./pull-api");
+
+class APIRegistry {
+  constructor() {
+    this.apis = {};
+    this.initialized = false;
+    this.registrationOrder = [];
+  }
+
+  initialize(engine) {
+    var resourceMap = engine.getResourceMap();
+    var info = engine.getInfo();
+    var path = require("path");
+
+    var modelAPI = new ModelAPI(resourceMap);
+    this.register("Model.API", modelAPI);
+
+    var worldGenAPI = new WorldGenAPI(modelAPI);
+    this.register("WorldGen.API", worldGenAPI);
+
+    var resourcesPath = path.join(engine.projectRoot, "src", info.resourcesfolder);
+    var pullAPI = new PullAPI(resourceMap, resourcesPath);
+    this.register("Pull.API", pullAPI);
+
+    this.initialized = true;
+    return this;
+  }
+
+  register(name, apiInstance) {
+    if (this.apis[name]) {
+      throw new Error("API already registered: " + name);
+    }
+
+    this.apis[name] = {
+      name: name,
+      instance: apiInstance,
+      callCount: 0,
+      lastCalled: null
+    };
+
+    this.registrationOrder.push(name);
+    return this;
+  }
+
+  get(name) {
+    if (!this.apis[name]) {
+      throw new Error("API not found: " + name);
+    }
+
+    return this.apis[name].instance;
+  }
+
+  execute(apiName, action, params) {
+    if (!this.apis[apiName]) {
+      throw new Error("API not registered: " + apiName);
+    }
+
+    var entry = this.apis[apiName];
+    entry.callCount++;
+    entry.lastCalled = new Date().toISOString();
+
+    return entry.instance.execute(action, params);
+  }
+
+  has(name) {
+    return this.apis[name] !== undefined;
+  }
+
+  list() {
+    var result = [];
+    for (var i = 0; i < this.registrationOrder.length; i++) {
+      var name = this.registrationOrder[i];
+      var entry = this.apis[name];
+      result.push({
+        name: name,
+        callCount: entry.callCount,
+        lastCalled: entry.lastCalled
+      });
+    }
+    return result;
+  }
+
+  getStats() {
+    var totalCalls = 0;
+    var apiCount = this.registrationOrder.length;
+
+    for (var i = 0; i < this.registrationOrder.length; i++) {
+      totalCalls += this.apis[this.registrationOrder[i]].callCount;
+    }
+
+    return {
+      apiCount: apiCount,
+      totalCalls: totalCalls,
+      initialized: this.initialized,
+      apis: this.list()
+    };
+  }
+
+  reset() {
+    for (var i = 0; i < this.registrationOrder.length; i++) {
+      var name = this.registrationOrder[i];
+      this.apis[name].callCount = 0;
+      this.apis[name].lastCalled = null;
+    }
+  }
+
+  unregister(name) {
+    if (!this.apis[name]) {
+      return false;
+    }
+
+    delete this.apis[name];
+
+    var idx = this.registrationOrder.indexOf(name);
+    if (idx !== -1) {
+      this.registrationOrder.splice(idx, 1);
+    }
+
+    return true;
+  }
+
+  validateDependencies(dependencies) {
+    var missing = [];
+    var found = [];
+
+    for (var i = 0; i < dependencies.length; i++) {
+      if (this.has(dependencies[i])) {
+        found.push(dependencies[i]);
+      } else {
+        missing.push(dependencies[i]);
+      }
+    }
+
+    return {
+      valid: missing.length === 0,
+      found: found,
+      missing: missing
+    };
+  }
+}
+
+module.exports = APIRegistry;

package/src/api/model-api.js

@@ -0,0 +1,274 @@
+const path = require("path");
+const fs = require("fs");
+
+class ModelAPI {
+  constructor(resourceMap, defaultModelsPath) {
+    this.resourceMap = resourceMap || {};
+    this.loadedModels = {};
+    this.defaultModelsPath = defaultModelsPath || path.join(__dirname, "..", "models", "defaults");
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "UseModel":
+        return this.useModel(params);
+      case "RemoveModel":
+        return this.removeModel(params);
+      case "ListModels":
+        return this.listModels();
+      default:
+        throw new Error("Unknown Model.API action: " + action);
+    }
+  }
+
+  useModel(params) {
+    if (!params || params.length === 0) {
+      throw new Error("UseModel requires a model name parameter");
+    }
+
+    const modelName = params[0];
+
+    if (this.loadedModels[modelName]) {
+      return this.loadedModels[modelName];
+    }
+
+    let resource = this.resourceMap[modelName];
+
+    if (!resource) {
+      resource = this.loadDefaultModel(modelName);
+    }
+
+    if (!resource) {
+      throw new Error("Model not found: " + modelName);
+    }
+
+    const model = this.loadModel(modelName, resource);
+    this.loadedModels[modelName] = model;
+    return model;
+  }
+
+  loadDefaultModel(modelName) {
+    const modelPath = path.join(this.defaultModelsPath, modelName.toLowerCase() + ".bbmodel");
+    const texturePath = path.join(this.defaultModelsPath, modelName.toLowerCase() + ".png");
+
+    if (fs.existsSync(modelPath)) {
+      return {
+        model: modelPath,
+        texture: fs.existsSync(texturePath) ? texturePath : null,
+        paired: fs.existsSync(texturePath),
+        isDefault: true
+      };
+    }
+
+    return null;
+  }
+
+  loadModel(name, resource) {
+    const result = {
+      name: name,
+      geometry: null,
+      texture: null,
+      uvMappings: null,
+      valid: false
+    };
+
+    if (resource.model) {
+      const modelData = this.parseBBModel(resource.model);
+      result.geometry = modelData.geometry;
+      result.uvMappings = modelData.uvMappings;
+    }
+
+    if (resource.texture) {
+      result.texture = this.loadTexture(resource.texture);
+    }
+
+    if (result.geometry && result.texture && result.uvMappings) {
+      result.uvMappings = this.validateAndFixUVMappings(result.uvMappings, result.texture);
+      result.valid = true;
+    } else if (result.geometry) {
+      result.valid = true;
+    }
+
+    return result;
+  }
+
+  parseBBModel(filePath) {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    let data;
+
+    try {
+      data = JSON.parse(raw);
+    } catch (e) {
+      throw new Error("Invalid .bbmodel file (not valid JSON): " + filePath);
+    }
+
+    const geometry = {
+      elements: [],
+      bones: [],
+      resolution: data.resolution || { width: 16, height: 16 }
+    };
+
+    const uvMappings = [];
+
+    if (data.elements && Array.isArray(data.elements)) {
+      for (const element of data.elements) {
+        const geomElement = {
+          name: element.name || "unnamed",
+          from: element.from || [0, 0, 0],
+          to: element.to || [1, 1, 1],
+          rotation: element.rotation || [0, 0, 0],
+          origin: element.origin || [0, 0, 0],
+          faces: {}
+        };
+
+        if (element.faces) {
+          const faceNames = ["north", "south", "east", "west", "up", "down"];
+          for (const faceName of faceNames) {
+            if (element.faces[faceName]) {
+              const face = element.faces[faceName];
+              geomElement.faces[faceName] = {
+                uv: face.uv || [0, 0, 16, 16],
+                texture: face.texture !== undefined ? face.texture : 0
+              };
+              uvMappings.push({
+                element: geomElement.name,
+                face: faceName,
+                uv: face.uv || [0, 0, 16, 16],
+                textureIndex: face.texture !== undefined ? face.texture : 0
+              });
+            }
+          }
+        }
+
+        geometry.elements.push(geomElement);
+      }
+    }
+
+    if (data.outliner && Array.isArray(data.outliner)) {
+      geometry.bones = this.parseOutliner(data.outliner);
+    }
+
+    return { geometry, uvMappings };
+  }
+
+  parseOutliner(outliner) {
+    const bones = [];
+
+    for (const item of outliner) {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const bone = {
+          name: item.name || "unnamed",
+          origin: item.origin || [0, 0, 0],
+          rotation: item.rotation || [0, 0, 0],
+          children: []
+        };
+
+        if (item.children && Array.isArray(item.children)) {
+          bone.children = this.parseOutliner(item.children);
+        }
+
+        bones.push(bone);
+      }
+    }
+
+    return bones;
+  }
+
+  loadTexture(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    const ext = path.extname(filePath).toLowerCase();
+    const buffer = fs.readFileSync(filePath);
+    let width = 0;
+    let height = 0;
+
+    if (ext === ".png") {
+      if (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
+    };
+  }
+
+  validateAndFixUVMappings(uvMappings, texture) {
+    if (!texture || texture.width === 0 || texture.height === 0) {
+      return uvMappings;
+    }
+
+    const fixed = [];
+
+    for (const mapping of uvMappings) {
+      const uv = mapping.uv;
+      let needsFix = false;
+
+      if (uv[0] < 0 || uv[1] < 0 || uv[2] < 0 || uv[3] < 0) {
+        needsFix = true;
+      }
+
+      if (uv[2] > texture.width || uv[3] > texture.height) {
+        needsFix = true;
+      }
+
+      if (needsFix) {
+        const fixedMapping = Object.assign({}, mapping);
+        fixedMapping.uv = [
+          Math.max(0, Math.min(uv[0], texture.width)),
+          Math.max(0, Math.min(uv[1], texture.height)),
+          Math.max(0, Math.min(uv[2], texture.width)),
+          Math.max(0, Math.min(uv[3], texture.height))
+        ];
+        fixedMapping.wasFixed = true;
+        fixed.push(fixedMapping);
+      } else {
+        fixed.push(mapping);
+      }
+    }
+
+    return fixed;
+  }
+
+  removeModel(params) {
+    if (!params || params.length === 0) {
+      throw new Error("RemoveModel requires a model name parameter");
+    }
+
+    const modelName = params[0];
+
+    if (!this.loadedModels[modelName]) {
+      throw new Error("Model not loaded: " + modelName);
+    }
+
+    delete this.loadedModels[modelName];
+    return { removed: modelName };
+  }
+
+  listModels() {
+    return Object.keys(this.loadedModels).map(function (name) {
+      return {
+        name: name,
+        valid: this.loadedModels[name].valid,
+        hasTexture: this.loadedModels[name].texture !== null
+      };
+    }.bind(this));
+  }
+
+  getLoadedModel(name) {
+    return this.loadedModels[name] || null;
+  }
+
+  isModelLoaded(name) {
+    return this.loadedModels[name] !== undefined;
+  }
+}
+
+module.exports = ModelAPI;