Hytale Modding

https://hytalemodding.dev/en/docs
Admin
Hytale Modding is a comprehensive resource for modding Hytale, a voxel-based sandbox RPG, enabling...
Tokens:200,035
Snippets:2,735
Trust Score:4.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Setup Method with HStats Initialization

Source: https://hytalemodding.dev/en/docs/guides/plugin/tracking-mod-analytics-with-hstats

This is an example of how your mod's setup method should look after initializing HStats. It includes the necessary line to start tracking.

```java
@Override
protected void setup() {
  super.setup();
  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
}
```

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

### Example Plugin Setup

Source: https://hytalemodding.dev/en/docs/guides/ecs/example-ecs-plugin

This is the main plugin class that sets up the game. It registers the custom command, event listeners, component, and system.

```java
package scot.oskar.hytaletemplate;

import dev.hytale.plugin.JavaPlugin;
import dev.hytale.plugin.JavaPluginInit;
import dev.hytale.ecs.component.ComponentType;
import dev.hytale.ecs.entity.EntityStore;
import scot.oskar.hytaletemplate.commands.ExampleCommand;
import scot.oskar.hytaletemplate.components.PoisonComponent;
import scot.oskar.hytaletemplate.events.ExampleEvent;
import scot.oskar.hytaletemplate.systems.PoisonSystem;
import scot.oskar.hytaletemplate.systems.ChatFormatter;
import dev.hytale.event.PlayerChatEvent;
import dev.hytale.event.PlayerReadyEvent;

import javax.annotation.Nonnull;

public final class ExamplePlugin extends JavaPlugin {

  private static ExamplePlugin instance;

  public ExamplePlugin(@Nonnull JavaPluginInit init) {
    super(init);
    instance = this;
  }

  @Override
  protected void setup() {
    this.getCommandRegistry().registerCommand(new ExampleCommand());
    this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
    this.getEventRegistry().registerGlobal(PlayerChatEvent.class, ChatFormatter::onPlayerChat);

    // Register the component & set the type in the component class so its easier to retrieve.
    ComponentType<EntityStore, PoisonComponent> poisonComponentType = this.getEntityStoreRegistry()
        .registerComponent(PoisonComponent.class, PoisonComponent::new);
    PoisonComponent.setComponentType(poisonComponentType);

    this.getEntityStoreRegistry().registerSystem(new PoisonSystem(PoisonComponent.getComponentType()));
  }

  public static ExamplePlugin get() {
    return instance;
  }
}

```

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

### Guide Frontmatter Example

Source: https://hytalemodding.dev/en/docs/contributing/writing-guides

Metadata for a guide file, including title, description, author information, and an icon. Ensure indentation is consistent.

```markdown
---
title: "Java Basics"
description: "Learn the basics of Java programming."
authors:
    - name: "Your Name"
      url: "https://yourwebsite.com"
icon: YourIcon 
---
```

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

### Instance Configuration Example

Source: https://hytalemodding.dev/en/docs/official-documentation/worldgen/worldgen-tutorial/README

An example of an Instance.bson configuration file, specifying world generation settings.

```json
{
  "WorldGen": {
    "Type": "HytaleGenerator",
    "WorldStructure": "Basic",
    "playerSpawn": {
      "X": 123,
      "Y": 480,
      "Z": 10000,
      "Pitch": 0,
      "Yaw": 0,
      "Roll": 0
    }
  }
}
```

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

### Setting the Start State for an NPC Role

Source: https://hytalemodding.dev/en/docs/guides/npc-workings/npc-states

This example demonstrates how to set the initial state for an NPC's role. It ensures that the NPC begins in the 'Idle' state, preventing validation errors.

```json
{
    "StartState":"Idle",
    "Instructions":[
        {
            "Instructions":[
                {
                    "Sensor":{
                        "Type":"State",
                        "State":"Idle"
                    },
                    "Actions":[
                        {
                            "Type":"Nothing"
                        }
                    ]
                }
            ]
        }
    ]
}
```

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

### Verify Tool Installation

Source: https://hytalemodding.dev/en/docs/guides/plugin/browsing-serverjar

Verify that Git, Maven, and Java are installed and accessible in your system's PATH.

```bash
git --version
```

```bash
mvn --version
```

```bash
java --version
```

```bash
jar --version
```

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

### Install Dependencies

Source: https://hytalemodding.dev/en/docs/guides/plugin/browsing-serverjar

Install the project dependencies using pip within the activated virtual environment.

```bash
pip install -r requirements.txt
```

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

### Install OpenJDK 25 via Scoop on Windows

Source: https://hytalemodding.dev/en/docs/guides/plugin/setting-up-env

Use Scoop, a command-line installer for Windows, to install OpenJDK 25. This is an alternative to the installer method.

```bash
scoop bucket add java
scoop install java/openjdk25
```

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

### Initialize HStats in Main Class

Source: https://hytalemodding.dev/en/docs/guides/plugin/tracking-mod-analytics-with-hstats

Add this line to your mod's setup method to start tracking analytics with HStats. Replace 'YOUR-MOD-UUID' with your mod's unique identifier and '1.0.0' with your mod's version.

```java
new HStats("YOUR-MOD-UUID", "1.0.0");
```

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

### Get Command Help

Source: https://hytalemodding.dev/en/docs/guides/prefabs

Displays help information for any prefab-related command, showing available options and usage.

```bash
/prefab save --help
```

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

### NPC State Machine Example

Source: https://hytalemodding.dev/en/docs/guides/npc-workings/npc-states

A comprehensive example demonstrating NPC state transitions, including sub-states like 'Farm.Goto' and 'Farm.Jobdriver'. This illustrates how to manage complex NPC behaviors.

```json
{
    "StartState":"Idle",
    "Instructions":[
        {
            "Instructions":[
                {
                    "$Comment":"Timer initialization.",
                    "Sensor":{
                        "Type":"Any",
                        "Once":true
                    }
                },
                {
                    "$Comment":"Work timer is triggered and we will check if we can do farm work. If we can go to the Farm state.",
                    "Continue":true,
                    "Actions":[
                        {
                            "Type":"State",
                            "State":"Farm.Goto"
                        }
                    ]
                },
                {
                    "Sensor":{
                        "Type":"State",
                        "State":"Idle"
                    }
                },
                {
                    "$Comment":"Main state of 'Farm' where our logic lies in.",
                    "Sensor":{
                        "Type":"State",
                        "State":"Farm.Goto"
                    },
                    "Instructions":[
                        {
                            "$Comment":"Perform checks to see if our Farming state fails, and if it does go back to being Idle.",
                            "Continue":true
                        },
                        {
                            "$Comment":"Go to our designated farming area.",
                            "Sensor":{
                                "Type":"State",
                                "State":".Goto"
                            },
                            "Instructions":[
                                {
                                    "$Comment":"Reached our destination. Switch to '.Jobdriver' sub-state.",
                                    "Actions":[
                                        {
                                            "Type":"State",
                                            "State":".Jobdriver"
                                        }
                                    ]
                                }
                            ]
                        },
                        {
                            "$Comment":"Perform farming job until we no longe can.",
                            "Sensor":{
                                "Type":"State",
                                "State":".Jobdriver"
                            }
                        }
                    ]
                }
            ]
        }
    ]
}
```

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

### ServerRulesCommand Example

Source: https://hytalemodding.dev/en/docs/guides/plugin/creating-commands

An example of an AbstractAsyncCommand that lists server rules. This command runs on a background thread and cannot directly edit world data.

```java
public class ServerRulesCommand extends AbstractAsyncCommand {

    public ServerRulesCommand() {
        super("rules", "Lists the servers rules");
    }

    @Override
    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
        context.sendMessage(Message.raw("The only rule is there are no rules."));
        return CompletableFuture.completedFuture(null);
    }
}
```

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

### Walk Motion Controller Example

Source: https://hytalemodding.dev/en/docs/guides/npc-workings/npc-role

An example configuration for a 'Walk' motion controller, specifying parameters like MaxWalkSpeed, Gravity, and Acceleration. This is typically used for ground-based NPCs.

```json
"MotionControllerList": [
    {
        "Type": "Walk",
        "MaxWalkSpeed": { "Compute": "MaxSpeed" },
        "Gravity": 10,
        "RunThreshold": 0.3,
        "MaxFallSpeed": 15,
        "MaxRotationSpeed": 360,
        "Acceleration": 10
    }
]
```

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

### NPC State Configuration Example

Source: https://hytalemodding.dev/en/docs/official-documentation/npc/10-attack-a-player

Example of an NPC state configuration, showing sensor types and actions.

```json
{
            "Attitudes": ["Hostile"]
        }
    },
	"Actions": [
		{
			"Type": "State",
			"State": "Alerted"
		}
	]
},
{
	"Sensor": {
		"Type": "State",
		"State:" ".Default"
	},
...
```

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

### Repository Structure Example

Source: https://hytalemodding.dev/en/docs/wiki/6-github

Illustrates the expected file structure for documentation within a GitHub repository intended for wiki sync.

```text
my-repo/
└── docs/
    ├── intro.md
    ├── installation.md
    └── usage.md
```

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

### BlockSpawner Plugin Example

Source: https://hytalemodding.dev/en/docs/established-information/server-plugin-insights

A basic plugin example demonstrating how to define custom block spawning rules. It utilizes the asset system and codecs for serialization.

```java
public class BlockSpawner {
    // ... plugin code ...
}
```

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

### Verify Java Installation

Source: https://hytalemodding.dev/en/docs/guides/plugin/setting-up-env

Check your installed Java version by running this command in your terminal. This confirms that the JDK has been successfully installed and is accessible.

```bash
java -version
```

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

### GlobalUpdateSystem Example

Source: https://hytalemodding.dev/en/docs/guides/ecs/systems

An example of a TickingSystem that runs once per tick globally. Use this for world-wide updates or logic not targeting specific entities.

```java
public class GlobalUpdateSystem extends TickingSystem<EntityStore> {

  @Override
  public void tick(float dt, int index, Store<EntityStore> store) {
    World world = store.getExternalData().getWorld();
  }
}
```

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

### Install Stripped JAR to Maven Local Repository

Source: https://hytalemodding.dev/en/docs/guides/plugin/browsing-serverjar

Install the stripped Hytale server JAR into your local Maven repository.

```bash
mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
```

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

### Registering a Custom System

Source: https://hytalemodding.dev/en/docs/guides/plugin/spawning-entities

Register your custom system within the plugin's setup function to enable its functionality for entity management.

```java
this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
```

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

### Category Configuration Example

Source: https://hytalemodding.dev/en/docs/wiki/6-github

Shows how to use a meta.json file to configure category titles and publication status for hierarchical documentation.

```json
{
  "title": "My Category",
  "published": true
}
```

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

### KeyedCodec Initialization

Source: https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory

Examples of initializing KeyedCodec instances for String and Integer fields using unique identifiers and built-in codecs.

```java
KeyedCodec<String> example = new KeyedCodec<String>("ExampleIdForCodec", Codec.STRING);
KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
```

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

### Basic Callout

Source: https://hytalemodding.dev/en/docs/contributing/writing-guides

Use this syntax to create a basic callout to highlight important information or tips within a guide.

```html
<Callout>
    This is a callout message.
</Callout>
```

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

### Basic Compute Parameter

Source: https://hytalemodding.dev/en/docs/guides/npc-workings/npc-role

A simple example of using 'Compute' to specify a parameter name.

```json
{ "Compute": "ParameterName" }
```

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

### NPC Combat Configuration Example

Source: https://hytalemodding.dev/en/docs/official-documentation/npc/11-melee-combat

This snippet shows configuration for an NPC's combat behavior, including stop distance and pathfinding settings.

```json
{
			"StopDistance": { "Compute": "LeashDistance * 0.2" },
			"RelativeSpeed": 0.8,
			"UsePathfinder": true
			}
		},
		{
			"Actions": [
				{
					"Type": "SetStat",
					"Stat": "Health",
					"Value": 1000000
				},
				{
					"Type": "State",
					"State": "Idle"
				}
			]
		}
	]
}
```

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

### Method Overloading Example

Source: https://hytalemodding.dev/en/docs/guides/java-basics/06-methods-functions

Demonstrates how to define multiple methods with the same name but different parameter lists. This allows for flexibility in how a method can be called.

```java
public static void displayMessage(String message) {
    System.out.println(message);
}

public static void displayMessage(String message, int times) {
    for (int i = 0; i < times; i++) {
        System.out.println(message);
    }
}

public static void main(String[] args) {
    displayMessage("Hello");           // Calls first version
    displayMessage("Hello", 3);        // Calls second version
}
```

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

### Reacting to Permission Changes

Source: https://hytalemodding.dev/en/docs/guides/plugin/permission-management

Provides example implementations for listening to permission and group change events within the Hytale event system.

```java
public class PermissionListener {

    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
        UUID playerUUID = event.getPlayerUuid();
        Set<String> added = event.getAddedPermissions();

        System.out.println("Permissions added to " + playerUUID + ": " + added);

        // Maybe notify the player or update cached data
    }

    public static void onGroupAdded(PlayerGroupEvent.Added event) {
        UUID playerUUID = event.getPlayerUuid();
        String groupName = event.getGroupName();

        System.out.println("Player " + playerUUID + " joined group: " + groupName);
    }
}
```

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

### Java Substring Indexing Example

Source: https://hytalemodding.dev/en/docs/guides/java-basics/09-string

Clarifies how `substring(start, end)` works in Java, including the start and end indices and the exclusion of the character at the end index.

```Java
String text = "Hytale";
//             012345 (indices)

text.substring(0, 2);  // "Hy" (indices 0 and 1)
text.substring(2, 6);  // "tale" (indices 2, 3, 4, 5)
text.substring(2);     // "tale" (from 2 to end)
```

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

### ExamplePlugin - Registers Components and Systems

Source: https://hytalemodding.dev/en/docs/guides/ecs/block-components

This plugin class is responsible for initializing and registering custom components and systems within the Hytale ECS. It ensures that the ExampleBlock component and related systems are available to the game.

```java
public class ExamplePlugin extends JavaPlugin {
    protected static ExamplePlugin instance;
    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
    private ComponentType exampleBlockComponentType;

    public static ExamplePlugin get() {
        return instance;
    }

    public ExamplePlugin(@Nonnull JavaPluginInit init) {
        super(init);
        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
    }

    @Override
    protected void setup() {
        instance = this;
        LOGGER.atInfo().log("Setting up plugin " + this.getName());
        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
    }
	
	override
	protected void start() {
		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
	}

    public ComponentType getExampleBlockComponentType() {
        return this.exampleBlockComponentType;
    }
}
```

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

### Command to Spawn Instance

Source: https://hytalemodding.dev/en/docs/guides/plugin/instances

An example command implementation for spawning a new instance from a template. It retrieves player and world context, determines a return point, and then executes the instance spawning logic.

```java
public class ExampleSpawnInstanceCommand extends CommandBase {
    private final RequiredArg<String> nameArg;

    public ExampleSpawnInstanceCommand() {
        super("spawninstance", "Spawns a new instance from a template");
        this.nameArg = this.withRequiredArg("name", "The name of the new instance", ArgTypes.STRING);
    }

    @Override
    protected void executeSync(@Nonnull CommandContext ctx) {
        UUID playerUUID = ctx.sender().getUuid();
        PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
        World world = Universe.get().getWorld(playerRef.getWorldUuid());

        ISpawnProvider spawnProvider = world.getWorldConfig().getSpawnProvider();
        Transform returnPoint = spawnProvider != null ? spawnProvider.getSpawnPoint(world, playerRef.getUuid()) : new Transform();

        world.execute(() -> {
            World instanceWorld = InstancesPlugin.get().spawnInstance(this.nameArg.get(ctx), world, returnPoint).join();
            Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
        });
    }
}
```

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

### Create and Use a Basic HashMap

Source: https://hytalemodding.dev/en/docs/guides/java-basics/11-hashmaps

Demonstrates creating a HashMap with String keys and Integer values, adding pairs, and retrieving a value by its key.

```java
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Create a HashMap (String keys, Integer values)
        HashMap<String, Integer> playerLevels = new HashMap<>();
        
        // Add key-value pairs
        playerLevels.put("Alice", 10);
        playerLevels.put("Bob", 15);
        playerLevels.put("Charlie", 8);
        
        // Get a value by key
        int aliceLevel = playerLevels.get("Alice");  // 10
        
        System.out.println("Alice is level " + aliceLevel);
    }
}
```

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

### Install OpenJDK 25 via Homebrew on macOS

Source: https://hytalemodding.dev/en/docs/guides/plugin/setting-up-env

Install OpenJDK 25 on macOS using Homebrew, a package manager for macOS. This command installs the specified JDK version.

```bash
brew install openjdk@25
```

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

### Run Setup Script

Source: https://hytalemodding.dev/en/docs/guides/plugin/browsing-serverjar

Execute the Python run script to set up the decompiled Hytale server project. Ensure HytaleServer.jar is in the root directory or its path is set via an environment variable.

```bash
python run.py setup
```

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

### Create and Use Item Objects in Java

Source: https://hytalemodding.dev/en/docs/guides/java-basics/07-introduction-oop

Demonstrates how to instantiate an Item object and call its methods like 'use' and 'getTotalWeight'.

```java
public class Main {
    public static void main(String[] args) {
        Item potion = new Item("Health Potion", "Consumable", 5, 0.5);
        
        potion.use();  // Used Health Potion. Remaining: 4
        System.out.println("Total weight: " + potion.getTotalWeight()); // 2.0
    }
}
```

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

### Install OpenJDK 25 via apt on Linux

Source: https://hytalemodding.dev/en/docs/guides/plugin/setting-up-env

Install OpenJDK 25 on Debian-based Linux distributions (like Ubuntu) using the system's package manager. This command updates the package list and installs the JDK.

```bash
sudo apt update
sudo apt install openjdk-25-jdk
```

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

### Define and Execute a Hytale Command with Various Argument Types

Source: https://hytalemodding.dev/en/docs/guides/plugin/creating-commands

This example demonstrates how to define a command with default, optional, and flag arguments. It shows how to access argument values and context within the execute method. Ensure you have the necessary command context when retrieving argument values.

```java
public class HealPlayerCommand extends AbstractTargetPlayerCommand {
    private final DefaultArg<Float> healthArg;
    private final OptionalArg<String> messageArg;
    private final FlagArg debugArg;

    public HealPlayerCommand() {
        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");

        // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
        // the use of `--player <value>` to specify someone else

        // args <Command String> <Description> <Default Value> <Desc of default value>
        this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");

        // Or you could do the following making the health value required instead of with a default.
        //    You would need to change the declaration to RequiredArg<Float>
        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);

// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
        this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);

        // No type needed due to being a bool
        this.debugArg = this.withFlagArg("debug", "Add debug logs");
    }

    @Override
    protected void execute(@NonNullDecl CommandContext commandContext, @NullableDecl Ref<EntityStore> ref, @NonNullDecl Ref<EntityStore> ref1, @NonNullDecl PlayerRef playerRef, @NonNullDecl World world, @NonNullDecl Store<EntityStore> store) {

        if (this.debugArg.get(commandContext) == true) { // <-- See commandContext passed to argument here
            commandContext.sendMessage(Message.raw("We are debugging"));
        }

        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
        EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
        int healthIdx = DefaultEntityStatTypes.getHealth();
        EntityStatValue health = stats.get(healthIdx);

        float missing = health.getMax() - health.get();

        if (this.debugArg.get(commandContext) == true) { // <-- See commandContext passed to argument here
            commandContext.sendMessage(Message.raw("Missing:  " + missing + " health"));
            commandContext.sendMessage(Message.raw("Adding:  " + healthArg.get(commandContext) + " health to "));
            commandContext.sendMessage(Message.raw(messageArg.get(commandContext)));
            commandContext.sendMessage(Message.raw("Input Value: " + healthArg.get(commandContext) + " Default"));
            commandContext.sendMessage(Message.raw("Default Health Value: "+healthArg.getDefaultValue()));
        }

        stats.addStatValue(healthIdx, healthArg.get(commandContext)); // <-- See commandContext passed to argument here
    }
}
```

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

### Player Inventory System Example in Java

Source: https://hytalemodding.dev/en/docs/guides/java-basics/05-arrays

Simulates a player's inventory using a string array, adding items and displaying the inventory status.

```Java
String[] inventory = new String[9]; // 9 hotbar slots

// Add items
inventory[0] = "Diamond Sword";
inventory[1] = "Shield";
inventory[8] = "Food";

// Display inventory
for (int i = 0; i < inventory.length; i++) {
    if (inventory[i] != null) {
        System.out.println("Slot " + i + ": " + inventory[i]);
    } else {
        System.out.println("Slot " + i + ": Empty");
    }
}
```

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

### Enter Instance Command

Source: https://hytalemodding.dev/en/docs/guides/plugin/instances

Spawns a new instance with a given name and immediately teleports the player into it. Requires the instance name as an argument.

```java
public class ExampleEnterInstanceCommand extends CommandBase {
    private final RequiredArg<String> nameArg;

    public ExampleEnterInstanceCommand() {
        super("enterinstance", "Spawns and enters an instance immediately");
        this.nameArg = this.withRequiredArg("name", "The name of the instance", ArgTypes.STRING);
    }

    @Override
    protected void executeSync(@Nonnull CommandContext ctx) {
        UUID playerUUID = ctx.sender().getUuid();
        PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
        World world = Universe.get().getWorld(playerRef.getWorldUuid());

        ISpawnProvider spawnProvider = world.getWorldConfig().getSpawnProvider();
        Transform returnPoint = spawnProvider != null ? spawnProvider.getSpawnPoint(world, playerRef.getUuid()) : new Transform();

        world.execute(() -> {
			//World instanceWorld = InstancesPlugin.get().spawnInstance(this.nameArg.get(ctx), world, returnPoint).join();
            //InstancesPlugin.teleportPlayerToInstance(playerRef.getReference(), playerRef.getReference().getStore(), instanceWorld, (Transform) null);	
            CompletableFuture<World> worldFuture = InstancesPlugin.get().spawnInstance(this.nameArg.get(ctx), world, returnPoint);
            InstancesPlugin.teleportPlayerToLoadingInstance(playerRef.getReference(), playerRef.getReference().getStore(), worldFuture, null);
        });
    }
}
```

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

### Icon Name Example

Source: https://hytalemodding.dev/en/docs/contributing/translate

Shows an example of an icon definition. The icon name itself must not be translated as it's a technical identifier.

```yaml
icon: Globe
```

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

### Full NPC Spawning Command Example

Source: https://hytalemodding.dev/en/docs/guides/plugin/spawning-npcs

This command spawns a 'Kweebec Sapling' NPC at the player's location, sets up its inventory with items and armor, and registers the command for use.

```java
import com.example.npc.NPCPlugin; // Adjust imports as necessary
import hytale.server.plugin.npc.INonPlayerCharacter;
import hytale.server.plugin.npc.NPCEntity;
// ... other imports

public class SpawnNpcCommand extends AbstractPlayerCommand {
    public SpawnNpcCommand() {
        // Register the command /npc which will trigger the "spawn npc" action
        super("npc", "spawn npc");
    }

    @Override
    protected void execute(@NonNullDecl CommandContext commandContext,
            @NonNullDecl Store<EntityStore> store,
            @NonNullDecl Ref<EntityStore> ref,
            @NonNullDecl PlayerRef playerRef,
            @NonNullDecl World world) {

        // Get the player's current position to spawn the NPC at the same location
        Vector3d position = playerRef.getTransform().getPosition();
        // Define the initial rotation (facing direction) for the NPC
        Vector3f rotation = new Vector3f(0, 0, 0);

        // Use the NPCPlugin helper to spawn the NPC.
        Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null,
                position, rotation);

        if (result != null) {
            // Successfully spawned
            Ref<EntityStore> npcRef = result.first();
            // Retrieve the NPC interface if needed for further interaction
            INonPlayerCharacter npc = result.second();

            // Set up the NPC's inventory and equipment
            setupNPCInventory(npcRef, store);
        }
    }

    /**
     * Configures the inventory for the spawned NPC.
     */
    public void setupNPCInventory(Ref<EntityStore> npcRef, Store<EntityStore> store) {
        // Retrieve the NPCEntity component to access inventory settings
        NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
        
        if (npcComponent == null)
            return;

        // Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
        npcComponent.setInventorySize(3, 9, 0);
        
        // Add items to the initialized inventory
        addItemsToNPCInventory(npcComponent.getInventory());
    }

    /**
     * Adds specific items and armor to the NPC's inventory.
     */
    public void addItemsToNPCInventory(Inventory inventory) {
        // Add a Thorium Mace to the first slot of the hotbar
        inventory.getHotbar().addItemStackToSlot((short) 0, new ItemStack("Weapon_Mace_Thorium", 1));
        
        // Equip a Thorium Helmet using the InventoryHelper
        InventoryHelper.useArmor(inventory.getArmor(), "Armor_Thorium_Head");
        
        // Set the active hotbar slot to the weapon
        inventory.setActiveHotbarSlot((byte) 0);
    }
}
```

```java
public class MyHytaleMod extends JavaPlugin {

    @Override
    protected void setup() {
        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
    }
}
```

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

### Gradle Build Failure: Hytale Not Found

Source: https://hytalemodding.dev/en/docs/guides/plugin/build-and-test

This error indicates Gradle cannot find the Hytale installation. Ensure the game is installed and the path is correctly configured.

```text
FAILURE: Build failed with an exception.

* What went wrong:
Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
```

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

### Basic Third-Person Camera Setup

Source: https://hytalemodding.dev/en/docs/guides/plugin/customizing-camera-controls

Sets up a basic third-person camera with adjustable zoom distance, perspective, and follow smoothness. Use this for a standard over-the-shoulder view.

```java
ServerCameraSettings settings = new ServerCameraSettings();
settings.distance = 10.0f;           // Zoom distance from player
settings.isFirstPerson = false;      // Third-person mode
settings.positionLerpSpeed = 0.2f;   // Smooth camera follow

playerRef.getPacketHandler().writeNoCache(
    new SetServerCamera(ClientCameraView.Custom, true, settings)
);
```

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

### Framework DecimalConstants Entry Example

Source: https://hytalemodding.dev/en/docs/official-documentation/worldgen/technical-hytale-generator/world-structure

An example of a DecimalConstants entry within the Framework module. This defines named decimal constants used in world generation.

```json
"Framework": [
  {
    "Type": "DecimalConstants",
    "Entries": [
      {
        "Name": "Base",
        "Value": 100
      }
    ]
  }
]
```

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

### PermissionAttachmentSystem Example

Source: https://hytalemodding.dev/en/docs/guides/ecs/systems

An example of a RefChangeSystem that listens for additions, updates, and removals of the PermissionAttachment component. It accesses entity data to log player UUIDs during these events.

```java
public class PermissionAttachmentSystem extends RefChangeSystem<EntityStore, PermissionAttachment> {

  private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();

  @Nonnull
  @Override
  public ComponentType<EntityStore, PermissionAttachment> componentType() {
    return EntityStoreRegistry.get().getPermissionAttachmentComponentType();
  }

  @Override
  public void onComponentAdded(@Nonnull Ref<EntityStore> ref, @Nonnull PermissionAttachment permissionAttachment, @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
    UUID playerUuid = component.getUuid();

    // PermissionAttachment component was added to a new entity
  }

  @Override
  public void onComponentSet(@Nonnull Ref<EntityStore> ref, @Nullable PermissionAttachment oldAttachment, @Nonnull PermissionAttachment newAttachment, @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
    UUID playerUuid = component.getUuid();

    // PermissionAttachment component was updated using replaceComponent or putComponent
  }

  @Override
  public void onComponentRemoved(@Nonnull Ref<EntityStore> ref, @Nonnull PermissionAttachment permissionAttachment, @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
    UUID playerUuid = component.getUuid();

    // PermissionAttachment component was removed from an entity
  }

  @Nullable
  @Override
  public Query<EntityStore> getQuery() {
    return EntityStoreRegistry.get().getPermissionAttachmentComponentType();
  }
}
```

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

### First Instruction Match Example

Source: https://hytalemodding.dev/en/docs/guides/npc-workings/npc-role

Illustrates the first instruction match within a nested structure, focusing on a player sensor and body motion. This snippet is evaluated if the initial state sensor matches.

```json
"Instructions":[
    {
        "Sensor": {
            "Type": "Player",
            "Range": 8,
            "Filters": [
                {
                    "Type": "ItemInHand",
                    "Items": ["Plant_Fruit_Berries_Red"]
                }
            ]
        },
        "HeadMotion": {
            "Type": "Watch"
        },
        "BodyMotion":{
            "Type":"Seek",
            "RelativeSpeed": 0.6,
            "StopDistance":3
        }
    },
    {
        "Reference": "Component_Instruction_Intelligent_Idle_Motion_Wander"
    }
]
```

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

### Get HashMap Size and Check if Empty

Source: https://hytalemodding.dev/en/docs/guides/java-basics/11-hashmaps

Demonstrates using `size()` to get the number of key-value pairs and `isEmpty()` to check if the HashMap contains any entries.

```java
HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);

int size = scores.size();         // 1
boolean empty = scores.isEmpty(); // false
```

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

### Get HashMap Values with Default

Source: https://hytalemodding.dev/en/docs/guides/java-basics/11-hashmaps

Demonstrates retrieving values using `get()`, which returns `null` for non-existent keys, and `getOrDefault()` to provide a fallback value.

```java
HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 100);

int score = scores.get("Alice");        // 100
Integer missing = scores.get("Dave");   // null (doesn't exist)

// Get with default value
int score2 = scores.getOrDefault("Dave", 0);  // 0 (returns default)
```

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

### Query Examples

Source: https://hytalemodding.dev/en/docs/guides/ecs/systems

Demonstrates how to construct queries to filter entities based on component presence or absence. Use Query.and() for required components and Query.not() for exclusions.

```java
// Single component - any entity with PoisonComponent
Query.and(poisonComponentType)

// Multiple components - entities with both
Query.and(poisonComponentType, Player.getComponentType())

// Exclusion - players that aren't dead
Query.and(Player.getComponentType(), Query.not(DeathComponent.getComponentType()))
```

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

### HealthRegenSystem Example

Source: https://hytalemodding.dev/en/docs/guides/ecs/systems

An example of a DelayedEntitySystem that executes its tick logic at a specified interval (1.0f second in this case) per matching entity. It queries for entities with the Player component.

```java
public class HealthRegenSystem extends DelayedEntitySystem<EntityStore> {

  public HealthRegenSystem() {
    super(1.0f);
  }

  @Override
  public void tick(float dt, int index, @Nonnull ArchetypeChunk<EntityStore> archetypeChunk,
      @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
    // Runs every 1 second per matching entity
  }

  @Nonnull
  @Override
  public Query<EntityStore> getQuery() {
    return Query.and(Player.getComponentType());
  }
}
```

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

### PoisonSystem Example

Source: https://hytalemodding.dev/en/docs/guides/ecs/systems

An example of an EntityTickingSystem that applies poison damage to entities over time. It uses delta time to manage elapsed time and tick intervals, removing the component when expired.

```java
public class PoisonSystem extends EntityTickingSystem<EntityStore> {

  private final ComponentType<EntityStore, PoisonComponent> poisonComponentType;

  public PoisonSystem(ComponentType<EntityStore, PoisonComponent> poisonComponentType) {
    this.poisonComponentType = poisonComponentType;
  }

  @Override
  public void tick(float dt, int index, @Nonnull ArchetypeChunk<EntityStore> archetypeChunk,
      @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {

    PoisonComponent poison = archetypeChunk.getComponent(index, poisonComponentType);
    Ref<EntityStore> ref = archetypeChunk.getReferenceTo(index);

    poison.addElapsedTime(dt);

    if (poison.getElapsedTime() >= poison.getTickInterval()) {
      poison.resetElapsedTime();

      Damage damage = new Damage(Damage.NULL_SOURCE, DamageCause.OUT_OF_WORLD, poison.getDamagePerTick());
      DamageSystems.executeDamage(ref, commandBuffer, damage);

      poison.decrementRemainingTicks();
    }

    if (poison.isExpired()) {
      commandBuffer.removeComponent(ref, poisonComponentType);
    }
  }

  @Nullable
  @Override
  public SystemGroup<EntityStore> getGroup() {
    return DamageModule.get().getGatherDamageGroup();
  }

  @Nonnull
  @Override
  public Query<EntityStore> getQuery() {
    return Query.and(this.poisonComponentType);
  }
}
```

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

### State Transitions with Actions

Source: https://hytalemodding.dev/en/docs/guides/npc-workings/npc-states

Defines actions to be performed between state transitions. This example clears targets and resets instructions when returning to the 'Idle' state.

```json
{
    "StateTransitions":[
        {
            "$Comment": "Always clear target and reset instructions when going back to idle.",
            "States": [
                {
                    "To": [ "Idle" ],
                    "From": [ ]
                }
            ],
            "Actions": [
                {
                    "Type": "ReleaseTarget"
                },
                {
                    "Type": "ResetInstructions"
                },
                {
                    "Type": "PlayAnimation",
                    "Slot": "Status"
                }
            ]
        }
    ]
}
```

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

### Java Infinite While Loop (Bad Example)

Source: https://hytalemodding.dev/en/docs/guides/java-basics/04-control-flow-loops

An example of an infinite loop where the condition never becomes false due to a forgotten update step. This will cause the program to run indefinitely.

```java
int x = 0;
while (x < 10) {
    System.out.println("Stuck!");
    // Forgot to increase x!
}
```

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

### Basic Property Types Examples

Source: https://hytalemodding.dev/en/docs/official-documentation/custom-ui/markup

Provides examples of basic property types in Hytale UI markup, including Boolean, Int, Float, String, Char, Color, Objects, and Arrays.

```markup
Visible: false;
Visible: true;
```

```markup
Height: 20;
```

```markup
Min: 0.2;
```

```markup
Text: "Hi!";
```

```markup
PasswordChar: "*";
```

```markup
Background: #ffffff;
```

```markup
Style: (Background: #ffffff)
```

```markup
TextSpans: [(Text: "Hi", IsBold: true)]
```

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

### Create and Use Player Objects

Source: https://hytalemodding.dev/en/docs/guides/java-basics/07-introduction-oop

This snippet demonstrates how to create instances (objects) of the 'Player' class, set their properties, and call their methods.

```java
public class Main {
    public static void main(String[] args) {
        // Create objects from the Player class
        Player player1 = new Player();
        player1.name = "Alice";
        player1.health = 100;
        player1.level = 5;
        
        Player player2 = new Player();
        player2.name = "Bob";
        player2.health = 80;
        player2.level = 3;
        
        // Use the objects
        player1.takeDamage(20);  // Alice took 20 damage!
        player2.takeDamage(15);  // Bob took 15 damage!
    }
}
```

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

### BuilderCodec for PoisonComponent

Source: https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory

Example of creating a BuilderCodec for a PoisonComponent with 'damagePerTick' and 'poisonName' fields.

```java
public class PoisonComponent implements Component<EntityStore> {
    private float damagePerTick;
    private String poisonName;

    // Constructors, getters, setters, clone method omitted for brevity

        public static final BuilderCodec<PoisonComponent> CODEC = BuilderCodec.builder(PoisonComponent.class, PoisonComponent::new)
            .append(
                new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
                (data, value) -> data.damagePerTick = value,
                (data) -> data.damagePerTick
            )
            .add()
            .append(
                new KeyedCodec<String>("PoisonName", Codec.STRING),
                (data, value) -> data.poisonName = value,
                (data) -> data.poisonName
            )
            .add()
            .build();
}
```

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

### Initialize Array with Values in Java

Source: https://hytalemodding.dev/en/docs/guides/java-basics/05-arrays

Create an integer array and populate it with initial values directly.

```Java
int[] numbers = {10, 20, 30, 40, 50};
```

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

### Get a User's Groups

Source: https://hytalemodding.dev/en/docs/guides/plugin/permission-management

Retrieves all groups a player is currently a member of.

```java
PermissionsModule perms = PermissionsModule.get();

// Get all groups the player belongs to
Set<String> groups = perms.getGroupsForUser(playerUUID);

for (String group : groups) {
    System.out.println("Player is in group: " + group);
}
```

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

### Get EntityStore Instance

Source: https://hytalemodding.dev/en/docs/guides/plugin/spawning-entities

Acquire an instance of Store<EntityStore> from the World object.

```java
Store<EntityStore> store = world.getEntityStore().getStore();
```

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

### Java Method Calling Examples

Source: https://hytalemodding.dev/en/docs/guides/java-basics/06-methods-functions

Illustrates the correct way to call a Java method. Ensure methods are invoked with parentheses, even if they have no parameters.

```java
// Wrong - Not calling the method
public static void main(String[] args) {
    greet;  // Error! Missing ()
}

// Correct
public static void main(String[] args) {
    greet();
}
```

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

### Create and Add Elements to an ArrayList

Source: https://hytalemodding.dev/en/docs/guides/java-basics/10-arraylist

Demonstrates how to create an ArrayList of Strings and add initial elements.

```Java
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Create an ArrayList of Strings
        ArrayList<String> players = new ArrayList<>();
        
        // Add elements
        players.add("Alice");
        players.add("Bob");
        players.add("Charlie");
        
        System.out.println(players);  // [Alice, Bob, Charlie]
    }
}
```

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

### Get Transform Component from Player

Source: https://hytalemodding.dev/en/docs/guides/plugin/playing-sounds

Obtain the TransformComponent for a player to determine sound origin.

```Java
TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
```

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

### Get Sound Index

Source: https://hytalemodding.dev/en/docs/guides/plugin/playing-sounds

Retrieve the index for a specific sound asset using the AssetMap.

```Java
int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
```

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

### Clone Repository and Navigate

Source: https://hytalemodding.dev/en/docs/guides/plugin/browsing-serverjar

Clone the Hytale Modding patcher repository and navigate into the directory.

```bash
git clone https://github.com/HytaleModding/patcher.git
cd patcher
```

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

### Java Modulus Operator Example

Source: https://hytalemodding.dev/en/docs/guides/java-basics/02-operators

Shows how the modulus operator (%) returns the remainder of a division operation.

```java
int remainder = 10 % 3; // 1 (because 10 divided by 3 is 3 with a remainder of 1)
```

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

### Example Callout Translation

Source: https://hytalemodding.dev/en/docs/contributing/translate

Demonstrates which parts of a callout should be translated and which should not. The 'type' attribute should remain in English.

```html
<Callout type="warning" title="Translate this title!">
Translate the text inside the callout!
</Callout>
```

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

### View Prefab Information

Source: https://hytalemodding.dev/en/docs/guides/prefabs

Displays general information about the currently selected prefab.

```bash
/editprefab info
```

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

### Get Cave Types from Zone

Source: https://hytalemodding.dev/en/docs/guides/plugin/world-gen

Retrieves the cave generator from a zone and checks if caves are defined for it.

```java
Zone zone = /* ... */;
CaveGenerator caveGen = zone.caveGenerator();
if (caveGen != null) {
    // This zone has caves
    CaveType[] types = caveGen.getCaveTypes();
}
```

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

### Creating Java Strings

Source: https://hytalemodding.dev/en/docs/guides/java-basics/09-string

Demonstrates the basic syntax for declaring and initializing String variables in Java.

```Java
String name = "Simon";
String message = "Welcome to Hytale!";
String empty = "";
```

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

### JSON Serial Interaction Example

Source: https://hytalemodding.dev/en/docs/guides/plugin/item-interaction

Defines a sequence of interactions to be executed one after another in the specified order.

```json
{
    "Type": "Serial",
    "Interactions": [
        {
            ... // first interaction
        },
        {
            ... // second interaction
        }
    ]
}
```

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

### Adding Validator to BuilderCodec Field

Source: https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory

Example of adding a validator to ensure the 'damagePerTick' field is greater than 0.

```java
.append(
    new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
    (data, value) -> data.damagePerTick = value,
    (data) -> data.damagePerTick
)
.addValidator(Validators.greaterThan(0))
```

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

### Getter Lambda Function Example

Source: https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory

A lambda function demonstrating how to retrieve a field value from a component instance.

```java
(data) -> data.myCustomField
```

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

### Setter Lambda Function Example

Source: https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory

A lambda function demonstrating how to set a field value on a component instance.

```java
(data, value) -> data.myCustomField = value
```

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

### List Available Prefabs

Source: https://hytalemodding.dev/en/docs/guides/prefabs

Displays a list of all prefabs currently saved on the file system.

```bash
/prefab list
```

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

### Custom UI Architecture Overview

Source: https://hytalemodding.dev/en/docs/official-documentation/custom-ui

Illustrates the command-based architecture for Hytale's Custom UI, showing the flow between the Java server and the C# client.

```mermaid
graph TD
    A[Java Server (Your Plugin)] --> B(C# Client (Game));
    A --> C{InteractiveCustomUI Page};
    C --> D(UICommandBuilder);
    D --> E(append());
    D --> F(set());
    D --> G(clear());
    D --> H(Commands sent to client);
    H --> I(Client parses .ui markup);
    I --> J(Creates visual elements);
    J --> K(User Interaction);
    K --> L(Events sent back to Java);
    L --> M{handleDataEvent()};
    M --> N(Process input);
    N --> O(sendUpdate());
    B --> P(CustomPage or CustomHud);
    P --> Q(Apply Element Tree);
    Q --> R(Layout);
    R --> S(Rendered UI);
```

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

### Registering Components and Systems in a Plugin

Source: https://hytalemodding.dev/en/docs/guides/ecs/systems

This snippet demonstrates how to register a custom component and a system within the setup method of a Hytale plugin. The ComponentType is stored for later access by systems.

```java
public final class ExamplePlugin extends JavaPlugin {

  private static ExamplePlugin instance;
  private ComponentType<EntityStore, PoisonComponent> poisonComponent;

  public ExamplePlugin(@Nonnull JavaPluginInit init) {
    super(init);
    instance = this;
  }

  @Override
  protected void setup() {
    this.getCommandRegistry().registerCommand(new ExampleCommand());
    this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
    this.getEventRegistry().registerGlobal(PlayerChatEvent.class, ChatFormatter::onPlayerChat);

    this.poisonComponent = this.getEntityStoreRegistry()
        .registerComponent(PoisonComponent.class, PoisonComponent::new);
    this.getEntityStoreRegistry().registerSystem(new PoisonSystem(this.poisonComponent));
  }

  public ComponentType<EntityStore, PoisonComponent> getPoisonComponentType() {
    return poisonComponent;
  }

  public static ExamplePlugin get() {
    return instance;
  }
}
```

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

### Retrieve Player Component

Source: https://hytalemodding.dev/en/docs/guides/plugin/player-death-event

Use the `Store` to get the `Player` component from the entity that triggered the death event.

```java
Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
```

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

### Get Array Length in Java

Source: https://hytalemodding.dev/en/docs/guides/java-basics/05-arrays

Retrieve the number of elements in an integer array using the `.length` property.

```Java
int[] scores = {45, 67, 89, 92, 55};
System.out.println(scores.length); // 5
```

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

### Example Mod JAR File

Source: https://hytalemodding.dev/en/docs/guides/plugin/build-and-test

After a successful build, your mod JAR file will be located in the `build/libs` directory. The name may vary based on your project configuration.

```text
ExamplePlugin-1.0.jar
```

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

### Setting up the Idle State in Instructions

Source: https://hytalemodding.dev/en/docs/official-documentation/npc/3-importance-of-being-idle

This snippet shows how to add the 'Idle' state sensor and its corresponding instruction to an NPC's configuration. It defines the basic structure for the Idle state.

```json
"Instructions": [
    {
        "Sensor": {
            "Type": "State",
            "State": "Idle"
        },
        "BodyMotion": {
            "Type": "Nothing"
        }
    }
]
```

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

### JSON Condition Interaction Example

Source: https://hytalemodding.dev/en/docs/guides/plugin/item-interaction

Configures an interaction to only proceed if the player is crouching. If the condition fails, the interaction is blocked.

```json
{
    "Type": "Condition",
    "Crouching": true, // only allow if player is crouching example
    "Failed": "Block_Secondary",
    "Next": {
        ... // next interaction to run if condition is met
    }
}
```

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

### Creating ArrayLists in Java

Source: https://hytalemodding.dev/en/docs/guides/java-basics/10-arraylist

Shows different ways to initialize an ArrayList, including empty, with initial values (Java 9+), and for various data types.

```Java
import java.util.ArrayList;

// Empty ArrayList
ArrayList<String> items = new ArrayList<>();

// With initial values (Java 9+)
ArrayList<String> colors = new ArrayList<>(List.of("Red", "Green", "Blue"));

// Different types
ArrayList<Integer> numbers = new ArrayList<>();
ArrayList<Double> prices = new ArrayList<>();
ArrayList<Boolean> flags = new ArrayList<>();
```

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

### Java Operator Precedence Example

Source: https://hytalemodding.dev/en/docs/guides/java-basics/02-operators

Demonstrates operator precedence, showing how the order of operations affects the evaluation of an expression.

```java
int result = 10 + 5 * 2; // result is 20, not 30
```
Tokens:
Raw