### Java: Update PromptBuilder System Prompt for New Action

Source: https://context7.com/yuvdwi/steve/llms.txt

This Java code shows how to update the system prompt used by the 'PromptBuilder' to inform the LLM about the new 'plant' action. It defines the action's name, expected parameters ('crop', 'quantity'), and provides an example of input and expected JSON output. This enables the LLM to generate natural language commands that can be translated into the new action. Dependencies include 'SteveMod.LOGGER'.

```java
// Step 3: Update PromptBuilder system prompt to teach LLM about new action
public static String buildSystemPrompt() {
    return """
        You are a Minecraft AI agent. Respond ONLY with valid JSON.

        ACTIONS:
        - attack: {"target": "hostile"}
        - build: {"structure": "house", "blocks": [...], "dimensions": [...]} 
        - mine: {"block": "iron", "quantity": 8}
        - plant: {"crop": "wheat", "quantity": 64}  // NEW ACTION
        - follow: {"player": "NAME"}

        EXAMPLES:
        Input: \"plant wheat\"
        {"reasoning": "Planting wheat crops", "plan": "Plant crops", "tasks": [{"action": "plant", "parameters": {"crop": "wheat", "quantity": 64}}]}
        """;
}

```

--------------------------------

### Natural Language Command Processing for Steve Agents (Java)

Source: https://context7.com/yuvdwi/steve/llms.txt

Illustrates how to send natural language commands to Steve agents, which are then processed by integrated LLMs (Groq, OpenAI, Gemini) to generate structured actions. It covers examples for mining, building, multi-agent coordination, and combat, along with stopping current actions and checking execution status. Also shows how prompts are constructed, including system prompts and context-aware user prompts.

```java
// Access a Steve entity's action executor
SteveEntity steve = SteveMod.getSteveManager().getSteve("Bob");
ActionExecutor executor = steve.getActionExecutor();

// Process natural language commands (async, uses LLM)
executor.processNaturalLanguageCommand("mine 20 iron ore");
// Steve will:
// 1. Send command to LLM (Groq/OpenAI/Gemini)
// 2. LLM returns JSON: {"reasoning": "Mining iron ore", "plan": "Mine iron", "tasks": [{"action": "mine", "parameters": {"block": "iron", "quantity": 20}}]}
// 3. Parse JSON into Task objects
// 4. Queue and execute tasks
// 5. Update memory with results

executor.processNaturalLanguageCommand("build a castle near me");
// LLM plans the structure build with appropriate materials and dimensions

executor.processNaturalLanguageCommand("help Alice build that tower");
// Multi-agent coordination - Bob will join Alice's building project

executor.processNaturalLanguageCommand("defend me from zombies");
// Combat action - Steve will attack hostile mobs

// Stop current action
executor.stopCurrentAction();
System.out.println("Is executing? " + executor.isExecuting()); // false

// Example of how the LLM prompt is constructed
String systemPrompt = PromptBuilder.buildSystemPrompt();
// Returns full JSON schema with available actions, rules, and examples

WorldKnowledge knowledge = new WorldKnowledge(steve);
String userPrompt = PromptBuilder.buildUserPrompt(steve, "build a house", knowledge);
// Returns context-aware prompt:
// === YOUR SITUATION ===
// Position: [100, 64, 200]
// Nearby Players: Alice (5m away)
// Nearby Entities: 3 sheep, 1 cow
// Nearby Blocks: grass, dirt, oak_log (15m away)
// Biome: Plains
// === PLAYER COMMAND ===
// "build a house"
```

--------------------------------

### Programmatic Mining with Steve Mod

Source: https://context7.com/yuvdwi/steve/llms.txt

Details how to programmatically initiate a mining task for specific resources using the Steve Mod. The code defines the target block and quantity, then creates and starts a mining action. The Steve entity will then intelligently navigate, locate, and mine the required resources, updating its memory upon completion.

```java
// Create a mining task
Task mineTask = new Task("mine");
mineTask.setParameter("block", "iron");
mineTask.setParameter("quantity", 20);

SteveEntity steve = SteveMod.getSteveManager().getSteve("Bob");
MineBlockAction mineAction = new MineBlockAction(steve, mineTask);
mineAction.start();

// Steve will:
// 1. Determine appropriate Y-level for iron (typically Y=0 to Y=64)
// 2. Navigate to mining depth using pathfinding
// 3. Search for iron ore blocks in a radius
// 4. Mine blocks until quantity reached
// 5. Update memory with "Mined 20 iron ore"
```

--------------------------------

### Mining Error Handling and Replanning

Source: https://context7.com/yuvdwi/steve/llms.txt

Provides an example of how the Steve Mod handles errors during mining operations. If a mining action fails, the system can provide a detailed error message and determine if replanning is necessary, prompting the Steve to ask for new instructions to find alternative resource locations.

```java
// Error handling example
if (mineAction.isComplete()) {
    ActionResult result = mineAction.getResult();
    if (!result.isSuccess()) {
        System.out.println("Mining failed: " + result.getMessage());
        if (result.requiresReplanning()) {
            // Steve will ask LLM to create new plan
            executor.processNaturalLanguageCommand("the ore wasn't there, find another location");
        }
    }
}
```

--------------------------------

### Accessing Configuration and AI Client (Java)

Source: https://context7.com/yuvdwi/steve/llms.txt

Demonstrates how to programmatically access configuration values set in the TOML file and how the AI client is initialized based on these settings. It shows retrieving AI provider, max Steves, and tick delay. It also illustrates sending requests to the AI planner, which automatically selects the configured provider and includes a fallback mechanism.

```Java
// Access configuration values in code
import com.steve.ai.config.SteveConfig;

String provider = SteveConfig.AI_PROVIDER.get();
System.out.println("Using AI provider: " + provider); // "groq"

int maxSteves = SteveConfig.MAX_ACTIVE_STEVES.get();
System.out.println("Max Steves allowed: " + maxSteves); // 10

int tickDelay = SteveConfig.ACTION_TICK_DELAY.get();
System.out.println("Action delay: " + tickDelay + " ticks"); // 20 (1 second)

boolean chatEnabled = SteveConfig.ENABLE_CHAT_RESPONSES.get();
if (chatEnabled) {
    steve.sendChatMessage("Task complete!");
}

// AI Client initialization (automatic based on config)
TaskPlanner planner = new TaskPlanner();
// Initializes OpenAIClient, GroqClient, and GeminiClient
// Selects active client based on SteveConfig.AI_PROVIDER

// Send request to configured AI provider
ResponseParser.ParsedResponse response = planner.planTasks(steve, "build a house");
if (response != null) {
    System.out.println("Plan: " + response.getPlan());
    System.out.println("Tasks: " + response.getTasks().size());
} else {
    System.out.println("AI request failed - check API key and provider");
}

// Provider fallback mechanism
// If primary provider fails, automatically tries Groq as fallback
// Example: If OpenAI API is down, falls back to Groq
String result = planner.getAIResponse("openai", systemPrompt, userPrompt);
// If OpenAI fails -> tries Groq
// If Groq also fails -> returns null

```

--------------------------------

### AI Provider Configuration (TOML)

Source: https://context7.com/yuvdwi/steve/llms.txt

Defines configuration settings for AI providers (Groq, OpenAI, Gemini) and general behavior parameters. It specifies API keys, model choices, token limits, temperature settings, and operational delays. This file dictates which AI services the Steve project will use and how it behaves.

```TOML
# config/steve-common.toml

[ai]
    # AI provider: "groq" (fast, free), "openai", or "gemini"
    provider = "groq"

[openai]
    # Get your API key from: https://platform.openai.com/api-keys
    apiKey = "sk-proj-..."
    model = "gpt-3.5-turbo"  # or "gpt-4-turbo-preview" for better planning
    maxTokens = 1000
    temperature = 0.7  # 0.0 = deterministic, 2.0 = creative

[groq]
    # Get free API key from: https://console.groq.com/keys
    apiKey = "gsk_..."
    model = "llama-3.1-8b-instant"  # Fast and free
    maxTokens = 8000
    temperature = 0.7

[gemini]
    # Get API key from: https://makersuite.google.com/app/apikey
    apiKey = "AIza..."
    model = "gemini-pro"
    maxTokens = 2048
    temperature = 0.7

[behavior]
    # Ticks between action checks (20 ticks = 1 second)
    actionTickDelay = 20

    # Allow Steves to respond in chat
    enableChatResponses = true

    # Maximum number of Steves active simultaneously
    maxActiveSteves = 10

```

--------------------------------

### Manage Steve Memory and State with NBT Persistence (Java)

Source: https://context7.com/yuvdwi/steve/llms.txt

This Java snippet illustrates how Steve agents manage their memory and state, including goals, recent actions, and task queues, utilizing NBT persistence for saving and loading. It also shows how to access world knowledge for contextual awareness, which is automatically included in LLM prompts for intelligent decision-making.

```java
import com.example.stevemod.*;
import com.example.stevemod.memory.*;
import com.example.stevemod.tasks.*;
import java.util.List;
import java.util.Queue;
import net.minecraft.nbt.CompoundTag;

SteveEntity steve = SteveMod.getSteveManager().getSteve("Bob");
SteveMemory memory = steve.getMemory();

// Set current goal
memory.setCurrentGoal("Build a castle for the player");
System.out.println("Current goal: " + memory.getCurrentGoal());

// Track recent actions (last 20 actions stored)
memory.addAction("Mined 20 iron ore");
memory.addAction("Crafted iron pickaxe");
memory.addAction("Built stone platform");

List<String> recentActions = memory.getRecentActions();
System.out.println("Recent actions:");
for (String action : recentActions) {
    System.out.println("  - " + action);
}
// Output:
//   - Mined 20 iron ore
//   - Crafted iron pickaxe
//   - Built stone platform

// Task queue management
Queue<Task> taskQueue = memory.getTaskQueue();
taskQueue.add(new Task("mine").setParameter("block", "iron").setParameter("quantity", 16));
taskQueue.add(new Task("build").setParameter("structure", "house"));
System.out.println("Queued tasks: " + taskQueue.size());

// Clear task queue (used by /steve stop command)
memory.clearTaskQueue();

// Memory persists with world saves via NBT
CompoundTag nbtTag = new CompoundTag();
memory.saveToNBT(nbtTag);
// Saves: currentGoal, taskQueue, recentActions

// Load memory when Steve spawns or world loads
memory.loadFromNBT(nbtTag);
System.out.println("Restored goal: " + memory.getCurrentGoal());

// World knowledge for contextual awareness
WorldKnowledge knowledge = new WorldKnowledge(steve);
System.out.println("Nearby players: " + knowledge.getNearbyPlayerNames());
// Output: "Alice (5m), Charlie (12m)"

System.out.println("Nearby entities: " + knowledge.getNearbyEntitiesSummary());
// Output: "5 sheep, 2 cows, 1 zombie"

System.out.println("Nearby blocks: " + knowledge.getNearbyBlocksSummary());
// Output: "grass, dirt, oak_log (15m), cobblestone (8m)"

System.out.println("Biome: " + knowledge.getBiomeName());
// Output: "Plains" (or "Forest", "Desert", etc.)

// This context is automatically included in LLM prompts
// to make Steve's decisions more intelligent and context-aware

```

--------------------------------

### Java: Execute Custom Action via Natural Language Command

Source: https://context7.com/yuvdwi/steve/llms.txt

This Java code demonstrates how to trigger the newly implemented custom action ('plant' action) using a natural language command processed by Steve AI. The command "plant 64 wheat on that farmland" is expected to be parsed by the LLM, which then generates a JSON task object. This task object is then processed by the 'executor', leading to the execution of the 'PlantCropsAction'. Dependencies include 'executor', 'natural language command processing'.

```java
// Now Steve can plant crops via natural language:
executor.processNaturalLanguageCommand("plant 64 wheat on that farmland");
// LLM generates: {"action": "plant", "parameters": {"crop": "wheat", "quantity": 64}}
// PlantCropsAction executes the task

```

--------------------------------

### Programmatic Structure Building with Steve Mod

Source: https://context7.com/yuvdwi/steve/llms.txt

Demonstrates how to programmatically create and execute a build task using the Steve Mod. It involves defining structure parameters and initiating the build action, which can be monitored for completion. This functionality supports both predefined NBT structures and procedurally generated ones like castles or towers.

```java
Task buildTask = new Task("build");
buildTask.setParameter("structure", "house");
buildTask.setParameter("blocks", List.of("oak_planks", "cobblestone", "glass_pane"));
buildTask.setParameter("dimensions", List.of(9, 6, 9)); // width, height, depth

// Execute the build task
SteveEntity steve = SteveMod.getSteveManager().getSteve("Bob");
BuildStructureAction buildAction = new BuildStructureAction(steve, buildTask);
buildAction.start();

// Monitor build progress (called every game tick)
buildAction.tick();
if (buildAction.isComplete()) {
    ActionResult result = buildAction.getResult();
    System.out.println("Build complete: " + result.getMessage());
    // Output: "Built house collaboratively!"
}
```

--------------------------------

### Spawning and Managing Steve Agents (Java)

Source: https://context7.com/yuvdwi/steve/llms.txt

Demonstrates how to spawn, list, and manage Steve AI agents programmatically using the `SteveManager`. It also shows how to check agent counts against configured limits and retrieve specific agent instances by name to access their current status and actions. This allows for dynamic control of agents within the Minecraft world.

```java
SteveManager manager = SteveMod.getSteveManager();
ServerLevel level = server.overworld();
Vec3 spawnPosition = new Vec3(100, 64, 200);
SteveEntity steve = manager.spawnSteve(level, spawnPosition, "Bob");

if (steve != null) {
    System.out.println("Successfully spawned: " + steve.getSteveName());
    // Steve is now active and will follow nearest player when idle
} else {
    System.out.println("Failed to spawn - name exists or max limit reached");
}

// Check current Steve count and limits
Collection<SteveEntity> allSteves = manager.getAllSteves();
System.out.println("Active Steves: " + allSteves.size() + "/" + SteveConfig.MAX_ACTIVE_STEVES.get());

// Get specific Steve by name
SteveEntity bob = manager.getSteve("Bob");
if (bob != null) {
    System.out.println("Bob's position: " + bob.blockPosition());
    System.out.println("Bob's current goal: " + bob.getActionExecutor().getCurrentGoal());
}
```

--------------------------------

### Java: Implement Custom PlantCropsAction for Steve AI

Source: https://context7.com/yuvdwi/steve/llms.txt

This Java code defines a custom action for Steve AI to plant crops. It extends the 'BaseAction' class, handling the planting logic, navigation to farmland, and crop placement. Dependencies include Minecraft's BlockPos, Blocks, and Steve AI's internal classes like 'ActionResult', 'Task', and 'SteveEntity'. It takes 'quantity' as a parameter and returns success or failure based on farmland availability and successful planting.

```java
// Step 1: Create custom action class extending BaseAction
package com.steve.ai.action.actions;

import com.steve.ai.action.ActionResult;
import com.steve.ai.action.Task;
import com.steve.ai.entity.SteveEntity;
import net.minecraft.core.BlockPos;
import net.minecraft.world.level.block.Blocks;

public class PlantCropsAction extends BaseAction {
    private BlockPos farmlandPos;
    private int cropsPlanted;
    private int targetCrops;

    public PlantCropsAction(SteveEntity steve, Task task) {
        super(steve, task);
    }

    @Override
    protected void onStart() {
        targetCrops = task.getIntParameter("quantity", 64);
        cropsPlanted = 0;

        // Find nearby farmland
        farmlandPos = findNearbyFarmland();
        if (farmlandPos == null) {
            result = ActionResult.failure("No farmland found nearby");
            return;
        }

        SteveMod.LOGGER.info("Steve '{}' starting to plant {} crops at {}",
            steve.getSteveName(), targetCrops, farmlandPos);
    }

    @Override
    protected void onTick() {
        if (cropsPlanted >= targetCrops) {
            result = ActionResult.success("Planted " + cropsPlanted + " crops");
            return;
        }

        // Navigate to farmland
        if (!steve.blockPosition().closerThan(farmlandPos, 2.0)) {
            steve.getNavigation().moveTo(farmlandPos.getX(), farmlandPos.getY(), farmlandPos.getZ(), 1.0);
            return;
        }

        // Plant wheat on farmland
        BlockPos cropPos = farmlandPos.above();
        if (steve.level().getBlockState(cropPos).isAir()) {
            steve.level().setBlock(cropPos, Blocks.WHEAT.defaultBlockState(), 3);
            cropsPlanted++;

            // Find next farmland position
            farmlandPos = farmlandPos.offset(1, 0, 0);
        }
    }

    @Override
    protected void onCancel() {
        steve.getNavigation().stop();
        SteveMod.LOGGER.info("Steve '{}' cancelled planting (planted {})",
            steve.getSteveName(), cropsPlanted);
    }

    @Override
    public String getDescription() {
        return "Plant crops (" + cropsPlanted + "/" + targetCrops + ")";
    }

    private BlockPos findNearbyFarmland() {
        BlockPos stevePos = steve.blockPosition();
        for (int x = -10; x <= 10; x++) {
            for (int z = -10; z <= 10; z++) {
                BlockPos checkPos = stevePos.offset(x, 0, z);
                if (steve.level().getBlockState(checkPos).getBlock() == Blocks.FARMLAND) {
                    return checkPos;
                }
            }
        }
        return null;
    }
}

```

--------------------------------

### Steve GUI Interface and Client Interaction (Java)

Source: https://context7.com/yuvdwi/steve/llms.txt

Manages the graphical user interface for the Steve AI, including toggling the panel, adding user, Steve, and system messages to the chat history, and sending commands. It details the visual styles of messages and outlines keyboard shortcuts and GUI features. The rendering is handled via a Forge event.

```Java
// Toggle GUI (bound to 'K' key by default)
SteveGUI.toggle();
boolean isOpen = SteveGUI.isOpen(); // true if panel visible

// Add messages to chat history (client-side only)
SteveGUI.addUserMessage("build a house near me");
// Displays in green bubble, right-aligned

SteveGUI.addSteveMessage("Bob", "Okay! I'll build a house for you.");
// Displays in blue bubble, left-aligned with Steve's name

SteveGUI.addSystemMessage("Spawning Steve agent: Bob");
// Displays in orange bubble for system notifications

// Message types and colors:
// - User messages: Green (#4CAF50), right-aligned
// - Steve responses: Blue (#2196F3), left-aligned with name
// - System messages: Orange (#FF9800), left-aligned

// GUI Features:
// - Scrollable message history (up to 500 messages)
// - Command input box at bottom
// - Command history (↑↓ arrow keys, stores last 50 commands)
// - Auto-scroll to latest message
// - Mouse scroll support for viewing history
// - Transparent overlay (doesn't block game view)
// - Smooth slide-in/out animation

// GUI keyboard shortcuts:
// - K: Toggle panel open/close
// - Enter: Send command
// - Esc: Close panel
// - ↑: Previous command from history
// - ↓: Next command from history
// - Mouse scroll: Scroll through messages

// Special command patterns recognized by GUI:
SteveGUI.sendCommand("spawn Alice");
// Executes: /steve spawn Alice

SteveGUI.sendCommand("all steves mine iron");
// Sends command to ALL active Steves
// Executes: /steve tell Bob mine iron
//           /steve tell Alice mine iron
//           /steve tell Charlie mine iron

SteveGUI.sendCommand("Bob, Alice build a castle");
// Comma-separated targets
// Sends to Bob and Alice only

// GUI rendering occurs every frame via Forge event
@SubscribeEvent
public static void onRenderOverlay(RenderGuiOverlayEvent.Post event) {
    // Renders transparent panel on right side
    // Shows header, message history, and input area
    // Automatically handles animation and scrolling
}

// Example integration in custom mod:
public class MyMod {
    @SubscribeEvent
    public void onKeyPress(KeyEvent event) {
        if (event.getKey() == GLFW.GLFW_KEY_K) {
            SteveGUI.toggle();
        }
    }
}

```

--------------------------------

### Natural Language Mining and Gathering Commands

Source: https://context7.com/yuvdwi/steve/llms.txt

Shows how natural language commands can be used to instruct a Steve entity to mine resources or gather materials. The system interprets these commands using an LLM to determine the action and parameters, including intelligently selecting mining depths and quantities for common resources like diamonds, coal, or wood.

```java
// Natural language mining commands:
executor.processNaturalLanguageCommand("get me 32 diamonds");
// LLM interprets as: {"action": "mine", "parameters": {"block": "diamond", "quantity": 32}}
// Steve navigates to Y=-64 to Y=16 (diamond level)

executor.processNaturalLanguageCommand("mine some coal");
// LLM determines reasonable quantity (e.g., 16)
// Steve mines at higher Y levels where coal is common

executor.processNaturalLanguageCommand("gather 64 oak logs");
// LLM interprets as gather action (different from mine)
// Steve finds oak trees and harvests logs
```

--------------------------------

### Command Steve Agents for Combat and Defense (Java)

Source: https://context7.com/yuvdwi/steve/llms.txt

This snippet demonstrates how to command Steve agents to attack hostile mobs and defend players. It covers creating combat tasks, initiating combat actions, and processing natural language commands for combat. Steve's combat attributes and coordinated defense with multiple Steves are also illustrated. Combat continues until the target is eliminated, out of range, a new command is received, or the Steve is manually stopped.

```java
import com.example.stevemod.*;
import com.example.stevemod.actions.*;
import com.example.stevemod.tasks.*;

// Create combat task
Task combatTask = new Task("attack");
combatTask.setParameter("target", "hostile"); // Target any hostile mob

SteveEntity steve = SteveMod.getSteveManager().getSteve("Bob");
CombatAction combatAction = new CombatAction(steve, combatTask);
combatAction.start();

// Steve will:
// 1. Scan for hostile entities within range (48 blocks)
// 2. Prioritize closest threat
// 3. Navigate to target using pathfinding
// 4. Attack with melee (8.0 damage)
// 5. Continue until target eliminated or out of range
// 6. Repeat for other hostiles

// Natural language combat commands:
// Assuming 'executor' is an instance of ActionExecutor or similar
// executor.processNaturalLanguageCommand("kill zombies near me");
// LLM: {"action": "attack", "parameters": {"target": "zombie"}}

// executor.processNaturalLanguageCommand("defend me");
// LLM: {"action": "attack", "parameters": {"target": "hostile"}}
// Steve attacks any hostile mob approaching player

// executor.processNaturalLanguageCommand("attack that creeper");
// LLM: {"action": "attack", "parameters": {"target": "creeper"}}

// Steve combat attributes (from SteveEntity.createAttributes())
// - Attack Damage: 8.0 (4 hearts)
// - Follow Range: 48.0 blocks
// - Movement Speed: 0.25
// - Always invulnerable (isInvulnerableTo() returns true)

// Example: Coordinated defense with multiple Steves
SteveManager manager = SteveMod.getSteveManager();
for (SteveEntity steveInstance : manager.getAllSteves()) {
    steveInstance.getActionExecutor().processNaturalLanguageCommand("defend the base");
}
// All Steves will patrol and attack any approaching hostiles

// Combat continues until:
// - Target is dead
// - Target moves out of range (>48 blocks)
// - Steve receives new command
// - Steve is manually stopped (/steve stop <name>)

```

--------------------------------

### Java: Update TaskPlanner Validation for New Action

Source: https://context7.com/yuvdwi/steve/llms.txt

This Java code snippet illustrates the necessary update to the 'TaskPlanner' for validating tasks involving the new 'plant' action. The 'validateTask' method is modified to check if the 'plant' action has the required parameters ('crop', 'quantity'). This ensures that tasks generated for the new action are well-formed before execution. Dependencies include 'Task'.

```java
// Step 4: Update TaskPlanner validation
public boolean validateTask(Task task) {
    return switch (task.getAction()) {
        case "plant" -> task.hasParameters("crop", "quantity");  // NEW VALIDATION
        case "mine" -> task.hasParameters("block", "quantity");
        // ... other validations
        default -> false;
    };
}

```

--------------------------------

### Collaborative Building with Multiple Steves

Source: https://context7.com/yuvdwi/steve/llms.txt

Illustrates how multiple Steve entities can collaborate on building a single structure, such as a castle. The system automatically divides work, assigns tasks to different Steves (e.g., by quadrant), and allows for monitoring of the collective progress. This leverages natural language commands to initiate and manage the collaborative effort.

```java
// Example: Collaborative building with multiple Steves
// Steve 1 receives command: "build a castle"
executor1.processNaturalLanguageCommand("build a castle");
// CollaborativeBuildManager creates a new build project
// Structure divided into 4 spatial quadrants (NW, NE, SW, SE)

// Steve 2 receives same command: "help with the castle"
executor2.processNaturalLanguageCommand("build a castle");
// Automatically joins existing castle build
// Assigned to different quadrant to avoid conflicts
// Both Steves work in parallel placing blocks

// Check collaborative build progress
CollaborativeBuildManager.CollaborativeBuild build = 
    CollaborativeBuildManager.findActiveBuild("castle");
if (build != null) {
    System.out.println("Progress: " + build.getProgressPercentage() + "%");
    System.out.println("Blocks placed: " + build.getBlocksPlaced() + "/" + build.getTotalBlocks());
    System.out.println("Steves working: " + build.participatingSteves.size());
}
```

--------------------------------

### Java: Register Custom Action in ActionExecutor for Steve AI

Source: https://context7.com/yuvdwi/steve/llms.txt

This Java code snippet demonstrates how to register a new custom action, 'PlantCropsAction', within the 'ActionExecutor' class. It modifies the 'createAction' method to include a case for the 'plant' action type. This allows the system to instantiate and use the custom action when prompted. Dependencies include 'BaseAction', 'SteveMod.LOGGER', and the custom action classes.

```java
// Step 2: Register action in ActionExecutor.createAction()
private BaseAction createAction(Task task) {
    return switch (task.getAction()) {
        case "pathfind" -> new PathfindAction(steve, task);
        case "mine" -> new MineBlockAction(steve, task);
        case "build" -> new BuildStructureAction(steve, task);
        case "plant" -> new PlantCropsAction(steve, task);  // NEW ACTION
        // ... other actions
        default -> {
            SteveMod.LOGGER.warn("Unknown action type: {}", task.getAction());
            yield null;
        }
    };
}

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.