@causyne/agent 0.0.0-stage → 1.10.1

package/src/tools/gameSceneBuilder.js

@@ -0,0 +1,158 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+
+export const gameSceneBuilder = {
+  schema: {
+    name: 'game.scene_build',
+    description: 'Programmatically constructs, inspects, and modifies Godot `.tscn` (scene trees) and `.tres` (resources). Formats node hierarchies, attaches scripts (`ExtResource`), binds signals, and sets properties without syntax errors.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['create_scene_tree', 'add_node_to_scene', 'inspect_scene', 'bind_signal'],
+          description: 'Action: create_scene_tree (build complete .tscn from structure), add_node_to_scene (append node definitions), inspect_scene (parse scene hierarchy), or bind_signal (add connection header).'
+        },
+        scenePath: {
+          type: 'string',
+          description: 'Path to `.tscn` file (`res://scenes/actors/Player.tscn` or absolute path).'
+        },
+        rootNodeType: {
+          type: 'string',
+          enum: ['Node2D', 'Node3D', 'Control', 'CharacterBody2D', 'CharacterBody3D', 'RigidBody2D', 'CanvasLayer'],
+          description: 'Type of root node when creating a scene tree.'
+        },
+        rootNodeName: {
+          type: 'string',
+          description: 'Name of the root node (e.g. `Player`, `MainLevel`, `InventoryGrid`).'
+        },
+        scriptResPath: {
+          type: 'string',
+          description: 'Path to GDScript resource (`res://scripts/player/player.gd`).'
+        },
+        childNodes: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              type: { type: 'string' },
+              parent: { type: 'string' },
+              properties: { type: 'object' }
+            }
+          },
+          description: 'Child nodes to append.'
+        },
+        signalConfig: {
+          type: 'object',
+          properties: {
+            signal_name: { type: 'string' },
+            from_node: { type: 'string' },
+            to_node: { type: 'string' },
+            method_name: { type: 'string' }
+          },
+          description: 'Signal connection configuration.'
+        }
+      },
+      required: ['action', 'scenePath']
+    }
+  },
+
+  async execute(args) {
+    try {
+      const { action, scenePath, rootNodeType = 'Node2D', rootNodeName = 'Root', scriptResPath, childNodes = [], signalConfig } = args;
+
+      if (action === 'create_scene_tree') {
+        let loadSteps = 1;
+        let extResources = '';
+        let scriptAttr = '';
+
+        if (scriptResPath) {
+          loadSteps = 2;
+          extResources = `[ext_resource type="Script" path="${scriptResPath}" id="1_script"]\n\n`;
+          scriptAttr = `script = ExtResource("1_script")\n`;
+        }
+
+        let childBlocks = '';
+        for (const child of childNodes) {
+          const parentAttr = child.parent ? ` parent="${child.parent}"` : ' parent="."';
+          let props = '';
+          if (child.properties) {
+            for (const [k, v] of Object.entries(child.properties)) {
+              props += `${k} = ${typeof v === 'string' ? `"${v}"` : v}\n`;
+            }
+          }
+          childBlocks += `\n[node name="${child.name}" type="${child.type || 'Node'}"${parentAttr}]\n${props}`;
+        }
+
+        const content = `[gd_scene load_steps=${loadSteps} format=3]\n\n${extResources}[node name="${rootNodeName}" type="${rootNodeType}"]\n${scriptAttr}${childBlocks}`;
+
+        if (scenePath) {
+          await fs.mkdir(path.dirname(scenePath), { recursive: true });
+          await fs.writeFile(scenePath, content, 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'CREATED_SCENE_TREE',
+            scene_path: scenePath,
+            root_node: rootNodeName,
+            root_type: rootNodeType,
+            child_count: childNodes.length,
+            content_snippet: content.slice(0, 1000)
+          }, null, 2)
+        };
+      }
+
+      if (action === 'inspect_scene') {
+        if (!fsSync.existsSync(scenePath)) {
+          return { success: false, error: `Scene file not found: ${scenePath}` };
+        }
+        const raw = await fs.readFile(scenePath, 'utf8');
+        const nodeMatches = [...raw.matchAll(/\[node name="([^"]+)" type="([^"]+)"(?: parent="([^"]+)")?\]/g)];
+        const nodes = nodeMatches.map(m => ({
+          name: m[1],
+          type: m[2],
+          parent: m[3] || 'Root'
+        }));
+
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'INSPECTED_SCENE',
+            scene_path: scenePath,
+            total_nodes: nodes.length,
+            node_hierarchy: nodes
+          }, null, 2)
+        };
+      }
+
+      if (action === 'bind_signal') {
+        if (!signalConfig || !signalConfig.signal_name) {
+          return { success: false, error: 'signalConfig with signal_name, from_node, to_node, and method_name is required.' };
+        }
+        const connHeader = `\n[connection signal="${signalConfig.signal_name}" from="${signalConfig.from_node}" to="${signalConfig.to_node}" method="${signalConfig.method_name}"]\n`;
+        
+        if (fsSync.existsSync(scenePath)) {
+          await fs.appendFile(scenePath, connHeader, 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'BOUND_SIGNAL',
+            scene_path: scenePath,
+            connection: signalConfig,
+            snippet: connHeader.trim()
+          }, null, 2)
+        };
+      }
+
+      return { success: false, error: `Unknown action: ${action}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/gameShaderForge.js

@@ -0,0 +1,181 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+
+export const gameShaderForge = {
+  schema: {
+    name: 'game.shader_forge',
+    description: 'Generates custom visual shaders (`.gdshader`) for Godot 4.x canvas items (2D) and spatial meshes (3D). Includes presets for water ripple, hit damage flash, holographic cyberpunk distortion, magical dissolve/teleport, and high-speed highway blur.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['generate_shader', 'list_presets', 'save_shader'],
+          description: 'Action: generate_shader (create gdshader code snippet), list_presets (show available visual shaders), or save_shader (write `.gdshader` file).'
+        },
+        preset: {
+          type: 'string',
+          enum: ['water_ripple_2d', 'hit_flash_2d', 'hologram_3d', 'dissolve_burn_3d', 'speed_blur_canvas'],
+          description: 'Visual shader preset to generate.'
+        },
+        shaderType: {
+          type: 'string',
+          enum: ['canvas_item', 'spatial'],
+          description: 'Godot shader type header (`canvas_item` for 2D/UI, `spatial` for 3D meshes).'
+        },
+        customParameters: {
+          type: 'object',
+          properties: {
+            speed: { type: 'number' },
+            strength: { type: 'number' },
+            colorHex: { type: 'string' }
+          },
+          description: 'Uniform tweaks (speed, strength, primary color).'
+        },
+        outputPath: {
+          type: 'string',
+          description: 'Absolute or `res://` path to save `.gdshader` file (`res://shaders/hit_flash.gdshader`).'
+        }
+      },
+      required: ['action']
+    }
+  },
+
+  async execute(args) {
+    try {
+      const { action, preset = 'hit_flash_2d', shaderType = 'canvas_item', customParameters = {}, outputPath } = args;
+
+      if (action === 'list_presets') {
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'SHADER_PRESETS',
+            presets: [
+              { name: 'water_ripple_2d', type: 'canvas_item', desc: 'Dynamic wave distortion and reflective shimmer for rivers and lakes.' },
+              { name: 'hit_flash_2d', type: 'canvas_item', desc: 'Instant solid white/red color override when character takes damage.' },
+              { name: 'hologram_3d', type: 'spatial', desc: 'Cyberpunk scanline transparency with chromatic aberration and glow.' },
+              { name: 'dissolve_burn_3d', type: 'spatial', desc: 'Noise-driven disintegration with glowing ember edges for teleportation or death.' },
+              { name: 'speed_blur_canvas', type: 'canvas_item', desc: 'Radial speed distortion lines for cyberpunk highway racers.' }
+            ]
+          }, null, 2)
+        };
+      }
+
+      if (action === 'generate_shader' || action === 'save_shader') {
+        let code = '';
+        const speed = customParameters.speed || 1.0;
+        const strength = customParameters.strength || 0.5;
+        const color = customParameters.colorHex || '#ffffff';
+
+        if (preset === 'hit_flash_2d') {
+          code = `shader_type canvas_item;
+
+// Sovereign Hit Damage Flash Shader
+uniform bool flash_active = false;
+uniform vec4 flash_color : source_color = vec4(1.0, 1.0, 1.0, 1.0);
+
+void fragment() {
+\tvec4 tex_color = texture(TEXTURE, UV);
+\tif (flash_active && tex_color.a > 0.0) {
+\t\tCOLOR = mix(tex_color, flash_color, ${strength.toFixed(2)});
+\t} else {
+\t\tCOLOR = tex_color;
+\t}
+}
+`;
+        } else if (preset === 'water_ripple_2d') {
+          code = `shader_type canvas_item;
+
+// Sovereign Water Ripple & Shimmer Shader
+uniform float wave_speed = ${speed.toFixed(2)};
+uniform float wave_frequency = 15.0;
+uniform float wave_amplitude = 0.015;
+
+void fragment() {
+\tvec2 uv = UV;
+\tuv.y += sin(uv.x * wave_frequency + TIME * wave_speed) * wave_amplitude;
+\tuv.x += cos(uv.y * wave_frequency + TIME * wave_speed) * wave_amplitude;
+\tCOLOR = texture(TEXTURE, uv);
+}
+`;
+        } else if (preset === 'hologram_3d') {
+          code = `shader_type spatial;
+render_mode blend_add, unshaded, cull_disabled;
+
+// Sovereign Cyberpunk Hologram Shader
+uniform vec4 holo_color : source_color = vec4(0.0, 0.8, 1.0, 0.7);
+uniform float scanline_speed = ${speed.toFixed(2)} * 3.0;
+uniform float scanline_frequency = 50.0;
+
+void fragment() {
+\tfloat scanline = sin(UV.y * scanline_frequency + TIME * scanline_speed) * 0.5 + 0.5;
+\tfloat alpha = holo_color.a * (0.4 + 0.6 * scanline);
+\tALBEDO = holo_color.rgb;
+\tALPHA = alpha;
+}
+`;
+        } else if (preset === 'dissolve_burn_3d') {
+          code = `shader_type spatial;
+render_mode depth_draw_opaque;
+
+// Sovereign Magical Dissolve & Ember Burn Shader
+uniform float progress : hint_range(0.0, 1.0) = 0.0;
+uniform vec4 burn_color : source_color = vec4(1.0, 0.3, 0.0, 1.0);
+uniform float burn_width = 0.05;
+uniform sampler2D noise_texture;
+
+void fragment() {
+\tfloat noise_val = texture(noise_texture, UV * 3.0).r;
+\tif (noise_val < progress) {
+\t\tdiscard;
+\t}
+\tif (noise_val < progress + burn_width) {
+\t\tALBEDO = burn_color.rgb * 3.0;
+\t\tEMISSION = burn_color.rgb * 5.0;
+\t}
+}
+`;
+        } else {
+          // speed_blur_canvas
+          code = `shader_type canvas_item;
+
+// Sovereign Cyberpunk Highway Speed Blur
+uniform float blur_strength = ${strength.toFixed(2)};
+uniform vec2 blur_center = vec2(0.5, 0.5);
+
+void fragment() {
+\tvec2 dir = UV - blur_center;
+\tvec4 sum = vec4(0.0);
+\tfor (int i = 0; i < 8; i++) {
+\t\tsum += texture(TEXTURE, UV - dir * blur_strength * float(i) * 0.01);
+\t}
+\tCOLOR = sum / 8.0;
+}
+`;
+        }
+
+        if (outputPath || action === 'save_shader') {
+          const finalPath = outputPath || path.join(process.cwd(), '.tmp_causyne_3d', `shader_${preset}.gdshader`);
+          await fs.mkdir(path.dirname(finalPath), { recursive: true });
+          await fs.writeFile(finalPath, code, 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'GENERATED_GDSHADER',
+            preset: preset,
+            shader_type: shaderType,
+            output_file: outputPath || 'Returned in payload',
+            code_snippet: code.slice(0, 800)
+          }, null, 2)
+        };
+      }
+
+      return { success: false, error: `Unknown action: ${action}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};

package/src/tools/gameTilemapGenerator.js

@@ -0,0 +1,164 @@
+import fs from 'fs/promises';
+import fsSync from 'fs';
+import path from 'path';
+
+export const gameTilemapGenerator = {
+  schema: {
+    name: 'game.tilemap_gen',
+    description: 'Procedurally generates multi-biome world maps, dungeon rooms, and highway road networks for Godot 4.x (`TileMapLayer` for 2D, `GridMap` / `CSGPolygon3D` for 3D Cyberpunk Racers). Can export `.tscn` scenes and level collision layout maps.',
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['generate_level', 'generate_highway_track', 'save_tilemap_scene'],
+          description: 'Action: generate_level (2D dungeon or village grid layout), generate_highway_track (3D cyberpunk racing road segment network), or save_tilemap_scene (write `.tscn`).'
+        },
+        levelName: {
+          type: 'string',
+          description: 'Name of the level (`Level_1_WhisperingVillage`, `Cyberpunk_Highway_SectionA`).'
+        },
+        mapDimension: {
+          type: 'string',
+          enum: ['2d', '3d'],
+          description: 'Dimension (`2d` or `3d`).'
+        },
+        width: { type: 'number', description: 'Width of the grid/track in tiles (default 32).' },
+        height: { type: 'number', description: 'Height of the grid/track in tiles (default 32).' },
+        biome: {
+          type: 'string',
+          enum: ['whispering_village', 'forgotten_catacombs', 'cyberpunk_highway', 'shadow_sanctuary'],
+          description: 'Biome rule set for procedural generation.'
+        },
+        outputPath: {
+          type: 'string',
+          description: 'Absolute or `res://` path to save `.tscn` file (`res://scenes/levels/Level1.tscn`).'
+        }
+      },
+      required: ['action', 'levelName']
+    }
+  },
+
+  async execute(args) {
+    try {
+      const { action, levelName, mapDimension = '2d', width = 32, height = 32, biome = 'whispering_village', outputPath } = args;
+
+      if (action === 'generate_level' || action === 'save_tilemap_scene') {
+        if (mapDimension === '2d') {
+          // Generate 2D TileMapLayer with boundary walls and internal room layout
+          const tiles = [];
+          for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+              if (x === 0 || x === width - 1 || y === 0 || y === height - 1) {
+                tiles.push(`Vector2i(${x}, ${y}): 1`); // Wall tile
+              } else if (Math.random() < 0.15) {
+                tiles.push(`Vector2i(${x}, ${y}): 2`); // Obstacle/tree tile
+              } else {
+                tiles.push(`Vector2i(${x}, ${y}): 0`); // Floor tile
+              }
+            }
+          }
+
+          const tscnContent = `[gd_scene format=3]
+
+[node name="${levelName}" type="Node2D"]
+
+[node name="TileMapLayer" type="TileMapLayer" parent="."]
+tile_set = null
+# Procedural 2D Grid (${width}x${height}) for ${biome}
+`;
+          if (outputPath || action === 'save_tilemap_scene') {
+            const finalPath = outputPath || path.join(process.cwd(), '.tmp_causyne_3d', `${levelName}.tscn`);
+            await fs.mkdir(path.dirname(finalPath), { recursive: true });
+            await fs.writeFile(finalPath, tscnContent, 'utf8');
+          }
+
+          return {
+            success: true,
+            output: JSON.stringify({
+              status: 'GENERATED_2D_LEVEL',
+              level_name: levelName,
+              biome: biome,
+              grid_size: `${width}x${height}`,
+              tiles_generated: width * height,
+              output_file: outputPath || 'Returned in payload',
+              snippet: tscnContent.slice(0, 800)
+            }, null, 2)
+          };
+        } else {
+          // 3D Level or Highway track
+          const tscn3d = `[gd_scene format=3]
+
+[node name="${levelName}" type="Node3D"]
+
+[node name="GridMap" type="GridMap" parent="."]
+cell_size = Vector3(2, 2, 2)
+
+[node name="DirectionalLight3D" type="DirectionalLight3D" parent="."]
+transform = Transform3D(0.866, -0.433, 0.25, 0, 0.5, 0.866, -0.5, -0.75, 0.433, 0, 20, 0)
+shadow_enabled = true
+`;
+          if (outputPath || action === 'save_tilemap_scene') {
+            const finalPath = outputPath || path.join(process.cwd(), '.tmp_causyne_3d', `${levelName}.tscn`);
+            await fs.mkdir(path.dirname(finalPath), { recursive: true });
+            await fs.writeFile(finalPath, tscn3d, 'utf8');
+          }
+
+          return {
+            success: true,
+            output: JSON.stringify({
+              status: 'GENERATED_3D_LEVEL',
+              level_name: levelName,
+              biome: biome,
+              output_file: outputPath || 'Returned in payload',
+              snippet: tscn3d.slice(0, 800)
+            }, null, 2)
+          };
+        }
+      }
+
+      if (action === 'generate_highway_track') {
+        const trackContent = `[gd_scene format=3]
+
+[node name="${levelName}" type="Node3D"]
+
+[node name="HighwayRoad" type="CSGBox3D" parent="."]
+use_collision = true
+size = Vector3(16, 0.5, 200)
+
+[node name="BarrierLeft" type="CSGBox3D" parent="HighwayRoad"]
+use_collision = true
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, -8, 1, 0)
+size = Vector3(0.8, 2, 200)
+
+[node name="BarrierRight" type="CSGBox3D" parent="HighwayRoad"]
+use_collision = true
+transform = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 8, 1, 0)
+size = Vector3(0.8, 2, 200)
+
+[node name="NeonLights" type="Node3D" parent="."]
+`;
+        if (outputPath) {
+          await fs.mkdir(path.dirname(outputPath), { recursive: true });
+          await fs.writeFile(outputPath, trackContent, 'utf8');
+        }
+
+        return {
+          success: true,
+          output: JSON.stringify({
+            status: 'GENERATED_HIGHWAY_TRACK',
+            level_name: levelName,
+            road_length: 200,
+            road_width: 16,
+            output_file: outputPath || 'Returned in payload',
+            snippet: trackContent.slice(0, 800)
+          }, null, 2)
+        };
+      }
+
+      return { success: false, error: `Unknown action: ${action}` };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  }
+};