Minecraft Bedrock MCP Server

Instructions

Implementation Reference

• src/tools/advanced/building/build-ellipsoid.ts:132-268 (handler)

  Main handler function that executes the build_ellipsoid tool. Validates inputs, computes ellipsoid positions, checks limits, and performs optimized block placement.

  async execute(args: {
      action?: string;
      centerX: number;
      centerY: number;
      centerZ: number;
      radiusX: number;
      radiusY: number;
      radiusZ: number;
      material?: string;
      hollow?: boolean;
  }): Promise<ToolCallResult> {
      try {
          // Socket-BE API接続確認
          if (!this.world) {
              return { success: false, message: "World not available. Ensure Minecraft is connected." };
          }
  
          // 引数の基本検証
          if (!args || typeof args !== 'object') {
              return this.createErrorResponse('Invalid arguments provided');
          }
  
          if (!this.validateArgs(args)) {
              return this.createErrorResponse('Missing required arguments: centerX, centerY, centerZ, radiusX, radiusY, radiusZ');
          }
  
          const { 
              action = 'build',
              centerX, 
              centerY, 
              centerZ, 
              radiusX, 
              radiusY, 
              radiusZ, 
              material = 'minecraft:stone', 
              hollow = false 
          } = args;
          
          // actionパラメータをサポート（現在は build のみ）
          if (action !== 'build') {
              return this.createErrorResponse(`Unknown action: ${action}. Only 'build' is supported.`);
          }
          
          // 座標の整数化
          const center = {
              x: this.normalizeCoordinate(centerX),
              y: this.normalizeCoordinate(centerY),
              z: this.normalizeCoordinate(centerZ)
          };
          
          const radiusXInt = Math.round(radiusX);
          const radiusYInt = Math.round(radiusY);
          const radiusZInt = Math.round(radiusZ);
          
          // パラメータ検証
          if (radiusXInt < 1 || radiusXInt > 50) {
              return this.createErrorResponse('X radius must be between 1 and 50');
          }
          
          if (radiusYInt < 1 || radiusYInt > 50) {
              return this.createErrorResponse('Y radius must be between 1 and 50');
          }
          
          if (radiusZInt < 1 || radiusZInt > 50) {
              return this.createErrorResponse('Z radius must be between 1 and 50');
          }
          
          // 座標範囲の検証
          const minX = center.x - radiusXInt;
          const maxX = center.x + radiusXInt;
          const minY = center.y - radiusYInt;
          const maxY = center.y + radiusYInt;
          const minZ = center.z - radiusZInt;
          const maxZ = center.z + radiusZInt;
          
          if (!this.validateCoordinates(minX, minY, minZ) || 
              !this.validateCoordinates(maxX, maxY, maxZ)) {
              return this.createErrorResponse('Ellipsoid extends beyond valid coordinates');
          }
          
          // ブロックIDの正規化
          const blockId = this.normalizeBlockId(material);
          
          const commands: string[] = [];
          let blocksPlaced = 0;
          
          // 楕円体形状の計算
          const radiusXSquared = radiusXInt * radiusXInt;
          const radiusYSquared = radiusYInt * radiusYInt;
          const radiusZSquared = radiusZInt * radiusZInt;
          
          
          // 楕円体の座標を計算
          const positions = calculateEllipsoidPositions(center, radiusXInt, radiusYInt, radiusZInt, hollow);
          
          // ブロック数制限チェック
          if (positions.length > BUILD_LIMITS.ELLIPSOID) {
              return this.createErrorResponse(`Too many blocks to place (maximum ${BUILD_LIMITS.ELLIPSOID.toLocaleString()})`);
          }
          
          try {
              // 最適化されたビルド実行
              const result = await executeBuildWithOptimization(
                  this.world,
                  positions,
                  blockId,
                  {
                      type: 'ellipsoid',
                      center: center,
                      radiusX: radiusXInt,
                      radiusY: radiusYInt,
                      radiusZ: radiusZInt,
                      material: blockId,
                      hollow: hollow,
                      apiUsed: 'Socket-BE'
                  }
              );
              
              if (!result.success) {
                  return this.createErrorResponse(result.message);
              }
              
              return {
                  success: true,
                  message: result.message,
                  data: result.data
              };
          } catch (buildError) {
              return this.createErrorResponse(`Building error: ${buildError instanceof Error ? buildError.message : String(buildError)}`);
          }
  
      } catch (error) {
          return this.createErrorResponse(
              `Error building ellipsoid: ${error instanceof Error ? error.message : String(error)}`
          );
      }
  }

• src/tools/advanced/building/build-ellipsoid.ts:44-95 (schema)

  Input schema defining parameters for building an ellipsoid: center coordinates, radii along each axis, material, and hollow option.

  readonly inputSchema: InputSchema = {
      type: 'object',
      properties: {
          action: {
              type: 'string',
              description: 'Build action to perform',
              enum: ['build'],
              default: 'build'
          },
          centerX: {
              type: 'number',
              description: 'Center X coordinate'
          },
          centerY: {
              type: 'number',
              description: 'Center Y coordinate'
          },
          centerZ: {
              type: 'number',
              description: 'Center Z coordinate'
          },
          radiusX: {
              type: 'number',
              description: 'Width radius (east-west stretch). Large=wide shape, Small=narrow shape. Example: 10=wide, 5=narrow',
              minimum: 1,
              maximum: 50
          },
          radiusY: {
              type: 'number',
              description: 'Height radius (vertical stretch). Large=tall shape, Small=flat shape. Example: 15=tall dome, 3=flat pancake',
              minimum: 1,
              maximum: 50
          },
          radiusZ: {
              type: 'number',
              description: 'Depth radius (north-south stretch). Large=deep shape, Small=shallow shape. Example: 8=deep, 4=shallow',
              minimum: 1,
              maximum: 50
          },
          material: {
              type: 'string',
              description: 'Block type to build with (e.g. stone, glass, concrete, wool for colorful sculptures)',
              default: 'minecraft:stone'
          },
          hollow: {
              type: 'boolean',
              description: 'Make it hollow (true) for shell/room inside, or solid (false) for full ellipsoid sculpture',
              default: false
          }
      },
      required: ['centerX', 'centerY', 'centerZ', 'radiusX', 'radiusY', 'radiusZ']
  };

• src/server.ts:348-372 (registration)

  BuildEllipsoidTool is instantiated and added to the tools array in initializeTools(), which is later registered with MCP server via registerModularTools() loop.

  this.tools = [
    // Socket-BE Core API ツール（推奨 - シンプルでAI使いやすい）
    new AgentTool(),
    new WorldTool(),
    new PlayerTool(),
    new BlocksTool(),
    new SystemTool(),
    new CameraTool(),
    new SequenceTool(),
    new MinecraftWikiTool(),
  
    // Advanced Building ツール（高レベル建築機能）
    new BuildCubeTool(), // ✅ 完全動作
    new BuildLineTool(), // ✅ 完全動作
    new BuildSphereTool(), // ✅ 完全動作
    new BuildCylinderTool(), // ✅ 修正済み
    new BuildParaboloidTool(), // ✅ 基本動作
    new BuildHyperboloidTool(), // ✅ 基本動作
    new BuildRotateTool(), // ✅ 基本動作
    new BuildTransformTool(), // ✅ 基本動作
    new BuildTorusTool(), // ✅ 修正完了
    new BuildHelixTool(), // ✅ 修正完了
    new BuildEllipsoidTool(), // ✅ 修正完了
    new BuildBezierTool(), // ✅ 新規追加（可変制御点ベジェ曲線）
  ];