@erik9994857/cag 1.0.3 → 2.0.2

package/defaults/main.cag

@@ -1,3 +1,8 @@
-Depency Model.API
-Depency WorldGen.API
-Depency Pull.API
+Dependency Model.API
+Dependency WorldGen.API
+Dependency Pull.API
+Dependency Chunk.API
+Dependency Player.API
+Dependency Camera.API
+Dependency Render.API
+Dependency Window.API

package/defaults/src/code/example.cagc

@@ -1,5 +1,39 @@
+// Default Game - CaG Engine Demo
+// This script sets up a flat 3D world with grass blocks and chunk loading
+
 Import Model.API
 Import WorldGen.API
+Import Chunk.API
+Import Player.API
+Import Camera.API
+Import Render.API
+Import Window.API
+
+// Configure the window
+{function use Window.API SetTitle Default Game
+{function use Window.API SetSize 1280 720
+
+// Configure rendering
+{function use Render.API SetSkyColor 0.53 0.81 0.92
+{function use Render.API SetFog 0.53 0.81 0.92 64 128
+{function use Render.API SetSunDirection 0.5 1.0 0.3
+{function use Render.API SetAmbientLight 0.3 0.3 0.4
+
+// Configure camera
+{function use Camera.API SetFOV 70
+{function use Camera.API SetMode first-person
 
+// Load the grass block model
 {function use Model.API UseModel Grass
+
+// Configure chunks - 16x16 blocks, render 1 chunk in every direction
+{function use Chunk.API SetSize 16
+{function use Chunk.API SetRenderDistance 1
+
+// Generate flat world with grass on top
 {function use WorldGen.API generate world top layer = Grass
+
+// Configure and spawn the player
+{function use Player.API SetSpeed 0.08
+{function use Player.API SetJumpHeight 0.18
+{function use Player.API Spawn 8 2 8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@erik9994857/cag",
-  "version": "1.0.3",
+  "version": "2.0.2",
   "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": {
@@ -30,8 +30,6 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {
-    "@electron/packager": "^18.3.0"
-  },
+  "dependencies": {},
   "devDependencies": {}
 }

package/src/api/api-registry.js

@@ -1,6 +1,11 @@
 const ModelAPI = require("./model-api");
 const WorldGenAPI = require("./worldgen-api");
 const PullAPI = require("./pull-api");
+const ChunkAPI = require("./chunk-api");
+const PlayerAPI = require("./player-api");
+const CameraAPI = require("./camera-api");
+const RenderAPI = require("./render-api");
+const WindowAPI = require("./window-api");
 
 class APIRegistry {
   constructor() {
@@ -24,6 +29,21 @@ class APIRegistry {
     var pullAPI = new PullAPI(resourceMap, resourcesPath);
     this.register("Pull.API", pullAPI);
 
+    var chunkAPI = new ChunkAPI();
+    this.register("Chunk.API", chunkAPI);
+
+    var playerAPI = new PlayerAPI();
+    this.register("Player.API", playerAPI);
+
+    var cameraAPI = new CameraAPI();
+    this.register("Camera.API", cameraAPI);
+
+    var renderAPI = new RenderAPI();
+    this.register("Render.API", renderAPI);
+
+    var windowAPI = new WindowAPI();
+    this.register("Window.API", windowAPI);
+
     this.initialized = true;
     return this;
   }

package/src/api/camera-api.js

@@ -0,0 +1,75 @@
+class CameraAPI {
+  constructor() {
+    this.fov = 70;
+    this.near = 0.1;
+    this.far = 300;
+    this.mode = "first-person";
+    this.sensitivity = 0.002;
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "SetFOV":
+        return this.setFOV(params);
+      case "SetNearFar":
+        return this.setNearFar(params);
+      case "SetMode":
+        return this.setMode(params);
+      case "SetSensitivity":
+        return this.setSensitivity(params);
+      case "GetSettings":
+        return this.getSettings();
+      default:
+        throw new Error("Unknown Camera.API action: " + action);
+    }
+  }
+
+  setFOV(params) {
+    if (params && params.length > 0) {
+      var val = parseFloat(params[0]);
+      if (!isNaN(val) && val >= 30 && val <= 120) {
+        this.fov = val;
+      }
+    }
+    return { fov: this.fov };
+  }
+
+  setNearFar(params) {
+    if (params && params.length >= 2) {
+      var n = parseFloat(params[0]);
+      var f = parseFloat(params[1]);
+      if (!isNaN(n)) this.near = n;
+      if (!isNaN(f)) this.far = f;
+    }
+    return { near: this.near, far: this.far };
+  }
+
+  setMode(params) {
+    if (params && params.length > 0) {
+      this.mode = params[0];
+    }
+    return { mode: this.mode };
+  }
+
+  setSensitivity(params) {
+    if (params && params.length > 0) {
+      var val = parseFloat(params[0]);
+      if (!isNaN(val) && val > 0) {
+        this.sensitivity = val;
+      }
+    }
+    return { sensitivity: this.sensitivity };
+  }
+
+  getSettings() {
+    return {
+      fov: this.fov,
+      near: this.near,
+      far: this.far,
+      mode: this.mode,
+      sensitivity: this.sensitivity
+    };
+  }
+}
+
+module.exports = CameraAPI;

package/src/api/chunk-api.js

@@ -0,0 +1,75 @@
+class ChunkAPI {
+  constructor() {
+    this.chunkSize = 16;
+    this.renderDistance = 1;
+    this.loadedChunks = {};
+    this.terrain = "flat";
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "SetSize":
+        return this.setSize(params);
+      case "SetRenderDistance":
+        return this.setRenderDistance(params);
+      case "Generate":
+        return this.generate(params);
+      case "Unload":
+        return this.unload(params);
+      case "ListLoaded":
+        return this.listLoaded();
+      default:
+        throw new Error("Unknown Chunk.API action: " + action);
+    }
+  }
+
+  setSize(params) {
+    if (params && params.length > 0) {
+      var size = parseInt(params[0], 10);
+      if (!isNaN(size) && size >= 4 && size <= 64) {
+        this.chunkSize = size;
+      }
+    }
+    return { chunkSize: this.chunkSize };
+  }
+
+  setRenderDistance(params) {
+    if (params && params.length > 0) {
+      var dist = parseInt(params[0], 10);
+      if (!isNaN(dist) && dist >= 1 && dist <= 16) {
+        this.renderDistance = dist;
+      }
+    }
+    return { renderDistance: this.renderDistance };
+  }
+
+  generate(params) {
+    var cx = 0;
+    var cz = 0;
+    if (params && params.length >= 2) {
+      cx = parseInt(params[0], 10) || 0;
+      cz = parseInt(params[1], 10) || 0;
+    }
+    var key = cx + "," + cz;
+    this.loadedChunks[key] = { cx: cx, cz: cz, generated: true };
+    return { chunkKey: key, cx: cx, cz: cz };
+  }
+
+  unload(params) {
+    var cx = 0;
+    var cz = 0;
+    if (params && params.length >= 2) {
+      cx = parseInt(params[0], 10) || 0;
+      cz = parseInt(params[1], 10) || 0;
+    }
+    var key = cx + "," + cz;
+    delete this.loadedChunks[key];
+    return { unloaded: key };
+  }
+
+  listLoaded() {
+    return Object.keys(this.loadedChunks);
+  }
+}
+
+module.exports = ChunkAPI;

package/src/api/model-api.js

@@ -72,14 +72,26 @@ class ModelAPI {
       valid: false
     };
 
+    let embeddedTextures = [];
+
     if (resource.model) {
       const modelData = this.parseBBModel(resource.model);
       result.geometry = modelData.geometry;
       result.uvMappings = modelData.uvMappings;
+      embeddedTextures = modelData.embeddedTextures || [];
     }
 
     if (resource.texture) {
       result.texture = this.loadTexture(resource.texture);
+    } else if (embeddedTextures.length > 0) {
+      result.texture = {
+        path: null,
+        width: result.geometry ? result.geometry.resolution.width : 16,
+        height: result.geometry ? result.geometry.resolution.height : 16,
+        format: "png",
+        size: 0,
+        dataURL: embeddedTextures[0].source
+      };
     }
 
     if (result.geometry && result.texture && result.uvMappings) {
@@ -148,7 +160,21 @@ class ModelAPI {
       geometry.bones = this.parseOutliner(data.outliner);
     }
 
-    return { geometry, uvMappings };
+    const embeddedTextures = [];
+    if (data.textures && Array.isArray(data.textures)) {
+      for (let i = 0; i < data.textures.length; i++) {
+        const tex = data.textures[i];
+        if (tex.source) {
+          embeddedTextures.push({
+            index: tex.id !== undefined ? tex.id : i,
+            name: tex.name || "texture_" + i,
+            source: tex.source
+          });
+        }
+      }
+    }
+
+    return { geometry, uvMappings, embeddedTextures };
   }
 
   parseOutliner(outliner) {
@@ -191,12 +217,16 @@ class ModelAPI {
       }
     }
 
+    const base64 = buffer.toString("base64");
+    const mime = ext === ".png" ? "image/png" : (ext === ".jpg" || ext === ".jpeg") ? "image/jpeg" : "image/" + ext.substring(1);
+
     return {
       path: filePath,
       width: width,
       height: height,
       format: ext.substring(1),
-      size: buffer.length
+      size: buffer.length,
+      dataURL: "data:" + mime + ";base64," + base64
     };
   }
 
@@ -269,6 +299,10 @@ class ModelAPI {
   isModelLoaded(name) {
     return this.loadedModels[name] !== undefined;
   }
+
+  getLoadedModels() {
+    return this.loadedModels;
+  }
 }
 
 module.exports = ModelAPI;

package/src/api/player-api.js

@@ -0,0 +1,74 @@
+class PlayerAPI {
+  constructor() {
+    this.spawnPoint = { x: 8, y: 2, z: 8 };
+    this.position = { x: 8, y: 2, z: 8 };
+    this.speed = 0.08;
+    this.jumpHeight = 0.18;
+    this.gravity = 0.015;
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "Spawn":
+        return this.spawn(params);
+      case "SetSpeed":
+        return this.setSpeed(params);
+      case "SetJumpHeight":
+        return this.setJumpHeight(params);
+      case "SetGravity":
+        return this.setGravity(params);
+      case "GetPosition":
+        return this.getPosition();
+      default:
+        throw new Error("Unknown Player.API action: " + action);
+    }
+  }
+
+  spawn(params) {
+    if (params && params.length >= 3) {
+      this.spawnPoint.x = parseFloat(params[0]) || 0;
+      this.spawnPoint.y = parseFloat(params[1]) || 0;
+      this.spawnPoint.z = parseFloat(params[2]) || 0;
+      this.position.x = this.spawnPoint.x;
+      this.position.y = this.spawnPoint.y;
+      this.position.z = this.spawnPoint.z;
+    }
+    return { spawnPoint: this.spawnPoint };
+  }
+
+  setSpeed(params) {
+    if (params && params.length > 0) {
+      var val = parseFloat(params[0]);
+      if (!isNaN(val) && val > 0) {
+        this.speed = val;
+      }
+    }
+    return { speed: this.speed };
+  }
+
+  setJumpHeight(params) {
+    if (params && params.length > 0) {
+      var val = parseFloat(params[0]);
+      if (!isNaN(val) && val > 0) {
+        this.jumpHeight = val;
+      }
+    }
+    return { jumpHeight: this.jumpHeight };
+  }
+
+  setGravity(params) {
+    if (params && params.length > 0) {
+      var val = parseFloat(params[0]);
+      if (!isNaN(val) && val > 0) {
+        this.gravity = val;
+      }
+    }
+    return { gravity: this.gravity };
+  }
+
+  getPosition() {
+    return { position: this.position };
+  }
+}
+
+module.exports = PlayerAPI;

package/src/api/render-api.js

@@ -0,0 +1,80 @@
+class RenderAPI {
+  constructor() {
+    this.skyColor = { r: 0.53, g: 0.81, b: 0.92 };
+    this.fogColor = { r: 0.53, g: 0.81, b: 0.92 };
+    this.fogNear = 64;
+    this.fogFar = 128;
+    this.sunDirection = { x: 0.5, y: 1.0, z: 0.3 };
+    this.ambientLight = { r: 0.3, g: 0.3, b: 0.4 };
+    this.renderDistance = 128;
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "SetFog":
+        return this.setFog(params);
+      case "SetSkyColor":
+        return this.setSkyColor(params);
+      case "SetSunDirection":
+        return this.setSunDirection(params);
+      case "SetAmbientLight":
+        return this.setAmbientLight(params);
+      case "SetRenderDistance":
+        return this.setRenderDist(params);
+      default:
+        throw new Error("Unknown Render.API action: " + action);
+    }
+  }
+
+  setFog(params) {
+    if (params && params.length >= 3) {
+      this.fogColor.r = parseFloat(params[0]) || 0;
+      this.fogColor.g = parseFloat(params[1]) || 0;
+      this.fogColor.b = parseFloat(params[2]) || 0;
+      if (params.length >= 5) {
+        this.fogNear = parseFloat(params[3]) || 64;
+        this.fogFar = parseFloat(params[4]) || 128;
+      }
+    }
+    return { fogColor: this.fogColor, fogNear: this.fogNear, fogFar: this.fogFar };
+  }
+
+  setSkyColor(params) {
+    if (params && params.length >= 3) {
+      this.skyColor.r = parseFloat(params[0]) || 0;
+      this.skyColor.g = parseFloat(params[1]) || 0;
+      this.skyColor.b = parseFloat(params[2]) || 0;
+    }
+    return { skyColor: this.skyColor };
+  }
+
+  setSunDirection(params) {
+    if (params && params.length >= 3) {
+      this.sunDirection.x = parseFloat(params[0]) || 0;
+      this.sunDirection.y = parseFloat(params[1]) || 0;
+      this.sunDirection.z = parseFloat(params[2]) || 0;
+    }
+    return { sunDirection: this.sunDirection };
+  }
+
+  setAmbientLight(params) {
+    if (params && params.length >= 3) {
+      this.ambientLight.r = parseFloat(params[0]) || 0;
+      this.ambientLight.g = parseFloat(params[1]) || 0;
+      this.ambientLight.b = parseFloat(params[2]) || 0;
+    }
+    return { ambientLight: this.ambientLight };
+  }
+
+  setRenderDist(params) {
+    if (params && params.length > 0) {
+      var val = parseFloat(params[0]);
+      if (!isNaN(val) && val > 0) {
+        this.renderDistance = val;
+      }
+    }
+    return { renderDistance: this.renderDistance };
+  }
+}
+
+module.exports = RenderAPI;

package/src/api/window-api.js

@@ -0,0 +1,69 @@
+class WindowAPI {
+  constructor() {
+    this.title = "CaG Engine";
+    this.width = 1280;
+    this.height = 720;
+    this.fullscreen = false;
+    this.background = "#1a1a2e";
+  }
+
+  execute(action, params) {
+    switch (action) {
+      case "SetTitle":
+        return this.setTitle(params);
+      case "SetSize":
+        return this.setSize(params);
+      case "SetFullscreen":
+        return this.setFullscreen(params);
+      case "SetBackground":
+        return this.setBackground(params);
+      case "GetSettings":
+        return this.getSettings();
+      default:
+        throw new Error("Unknown Window.API action: " + action);
+    }
+  }
+
+  setTitle(params) {
+    if (params && params.length > 0) {
+      this.title = params.join(" ");
+    }
+    return { title: this.title };
+  }
+
+  setSize(params) {
+    if (params && params.length >= 2) {
+      var w = parseInt(params[0], 10);
+      var h = parseInt(params[1], 10);
+      if (!isNaN(w) && w > 0) this.width = w;
+      if (!isNaN(h) && h > 0) this.height = h;
+    }
+    return { width: this.width, height: this.height };
+  }
+
+  setFullscreen(params) {
+    if (params && params.length > 0) {
+      this.fullscreen = params[0] === "true" || params[0] === true;
+    }
+    return { fullscreen: this.fullscreen };
+  }
+
+  setBackground(params) {
+    if (params && params.length > 0) {
+      this.background = params[0];
+    }
+    return { background: this.background };
+  }
+
+  getSettings() {
+    return {
+      title: this.title,
+      width: this.width,
+      height: this.height,
+      fullscreen: this.fullscreen,
+      background: this.background
+    };
+  }
+}
+
+module.exports = WindowAPI;